Converted to correct J letter

2022-10-31 04:39:32 +01:00 · 2022-10-31 04:39:32 +01:00 · 045ae94065
commit 045ae94065
parent a366c75602
405 changed files with 1022 additions and 1007 deletions
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբ.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբ.java
@ -0,0 +1,151 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ.BasicStringBuilder;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ.ױזױזזךױזזױזזךזזזךױךױזזזךױז;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ.स्ट्रिंगबिल्डर;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ.字符串生成器;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ.𓌾𓍁𓀝𓇏;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface StringBuilderբ extends Babelizeբᴬᵖᶦ,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ßabel,
+	StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ßabel
+	{
+	interface ßabelAscii extends
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ßabelAscii,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ßabelAscii
+		{
+	}
+	public interface ßabelMandarin extends
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ßabelMandarin,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ßabelMandarin
+		{
+	}
+	interface ßabelHindi extends
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ßabelHindi,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ßabelHindi
+		{
+	}
+	interface ßabelHiero extends
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ßabelHiero,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ßabelHiero
+		{
+	}
+	interface ßabelHinarī extends
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendBoolean.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendChar.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArray.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharArrayOffset.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequence.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCharSequenceOffset.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendDouble.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendFloat.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendInt.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendLong.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendObject.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendString.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringUnicode.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendStringBuffer.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒAppendCodePoint.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCapacity.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCharAt.ßabelHinarī,
+		StringBuilderᴬᵖᶦ.ƉěꬵḭȵᶒCodePointAt.ßabelHinarī
+		{
+	}
+	
+	default BasicStringBuilder toBabelAscii() { return new BasicStringBuilder(StringBuilderբ.this); }
+	default 字符串生成器  toBabelMandarin() { return new 字符串生成器(StringBuilderբ.this); }
+	default स्ट्रिंगबिल्डर toBabelHindi() { return new स्ट्रिंगबिल्डर(StringBuilderբ.this) ;}
+	default 𓌾𓍁𓀝𓇏 toBabelHiero() { return new 𓌾𓍁𓀝𓇏(StringBuilderբ.this);}
+	default ױזױזזךױזזױזזךזזזךױךױזזזךױז toBabelHinarī() { return new ױזױזזךױזזױזזךזזזךױךױזזזךױז(StringBuilderբ.this);}
+	
+	public static StringBuilderբ instanceᴺᵉʷ() {
+		return wrapᴼᶠ(new StringBuilder());
+	}
+	
+	public static StringBuilderբ wrapᴼᶠ(StringBuilder buf) {
+		return new StringBuilderբᵂʳᵃᵖ(buf);
+	}
+	
+	public static StringBuilder wrapᴼᶠ(StringBuilderբᵂʳᵃᵖ buf) {
+		return buf.unwrap();
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբᵂʳᵃᵖ.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբᵂʳᵃᵖ.java
@ -0,0 +1,134 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public final class StringBuilderբᵂʳᵃᵖ implements StringBuilderբ {
+
+	private final StringBuilder data;
+	
+	protected StringBuilderբᵂʳᵃᵖ(StringBuilder data) {
+		this.data = data;
+	}
+	
+	protected StringBuilder unwrap() {
+		return data;
+	}
+	
+	@Override
+	public StringBuilderբ toBabel() {
+		return this;
+	}
+	
+	@Override
+	public String toString() {
+		return data.toString();
+	}
+	
+	// ---------- interface
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(boolean o) {
+		data.append(o);
+		return this;
+	}
+
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(char o) {
+		data.append(o);
+		return this;
+	}
+
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(char[] o) {
+		data.append(o);
+		return this;
+	}
+
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(char[] o, int off, int len) {
+		data.append(o, off, len);
+		return this;
+	}
+
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(CharSequence o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(CharSequence o, int start, int end) {
+		data.append(o, start, end);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(double o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(float o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(int o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(long o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(Object o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(String o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(StringUnicode o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenᕀᕀ(StringBuffer o) {
+		data.append(o);
+		return this;
+	}
+	
+	@Override
+	public StringBuilderբ toefügenCodePunktᕀᕀ(int o) {
+		data.appendCodePoint(o);
+		return this;
+	}
+	
+	@Override
+	public int kapazität() {
+		return data.capacity();
+	}
+	
+	@Override
+	public char zeichenBei(int o) {
+		return data.charAt(o);
+	}
+	
+	@Override
+	public int codePunktOpf(int o) {
+		return data.codePointAt(o);
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբ抽.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderբ抽.java
@ -0,0 +1,23 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+abstract public class StringBuilderբ抽<P> implements StringBuilderᴬᵖᶦ.Ꝑŕḯṿª₮ḕ.ꞱBuilder<P> {
+
+	private final StringBuilderբ wrap;
+	
+	protected StringBuilderբ抽(StringBuilderբ wrap) {
+		this.wrap = wrap;
+	}
+	
+	@Override
+	public StringBuilderբ toBabel() {
+		return wrap;
+	}
+	
+	@Override
+	public String toString() {
+		return toBabel().toString();
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderᴬᵖᶦ.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringBuilderᴬᵖᶦ.java
@ -0,0 +1,197 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import java.util.function.Consumer;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelMethodƉěꬵḭȵᶒᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelTypeTowerßբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelTypeꝐŕḯṿª₮ḕᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelAscii;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public enum StringBuilderᴬᵖᶦ implements Babelizeբᴬᵖᶦ {
+	;
+	enum Ꝑŕḯṿª₮ḕ implements BabelTypeꝐŕḯṿª₮ḕᴬᵖᶦ {
+		;
+		interface ꞱBuilder<P> extends BabelTypeTowerßբᴬᵖᶦ<StringBuilderբ> {
+			@SuppressWarnings("unchecked")
+			default P make(Consumer<StringBuilderբ> build) {
+				build.accept(toBabel());
+				return (P) this;
+			}
+		}
+		interface ꞱElevator extends ꞱBuilder<StringBuilderբ>,BabelAscii {}
+		interface ꞱAscii extends ꞱBuilder<StringBuilderբ.ßabelAscii>,BabelAscii {}
+		interface ꞱMandarin extends ꞱBuilder<StringBuilderբ.ßabelMandarin>,BabelMandarin {}
+		interface ꞱHindi extends ꞱBuilder<StringBuilderբ.ßabelHindi>,BabelHindi {}
+		interface ꞱHiero extends ꞱBuilder<StringBuilderբ.ßabelHiero>,BabelHiero {}
+		interface ꞱHinarī extends ꞱBuilder<StringBuilderբ.ßabelHinarī>,BabelHinarī {}
+	}
+	enum ƉěꬵḭȵᶒAppendBoolean implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(boolean o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(boolean o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendChar implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(char o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(char o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendCharArray implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(char[] o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(char[] o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendCharArrayOffset implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(char[] o, int off, int len); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(char[] o, int off, int len) { return make(v -> v.toefügenᕀᕀ(o,off,len)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendCharSequence implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(CharSequence o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(CharSequence o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendCharSequenceOffset implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(CharSequence o, int start, int end); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(CharSequence o, int start, int end) { return make(v -> v.toefügenᕀᕀ(o,start,end)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendDouble implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(double o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(double o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendFloat implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(float o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(float o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendInt implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(int o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(int o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendLong implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(long o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(long o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendObject implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(Object o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(Object o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendString implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(String o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(String o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendStringUnicode implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(StringUnicode o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(StringUnicode o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendStringBuffer implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenᕀᕀ(StringBuffer o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii append(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़ना(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזזז(StringBuffer o) { return make(v -> v.toefügenᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒAppendCodePoint implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { StringBuilderբ toefügenCodePunktᕀᕀ(int o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default StringBuilderբ.ßabelAscii appendCodePoint(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default StringBuilderբ.ßabelMandarin 附加龸代碼龸觀點(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default StringBuilderբ.ßabelHindi जोड़नाꣻकोडꣻबिंदु(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default StringBuilderբ.ßabelHiero 𓆒𓀜𓐗𓊏𓀄(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default StringBuilderբ.ßabelHinarī ךױזױזזזױזזז(int o) { return make(v -> v.toefügenCodePunktᕀᕀ(o)); } }
+	}
+	enum ƉěꬵḭȵᶒCapacity implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { int kapazität(); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default int capacity() { return toBabel().kapazität(); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default int 容量() { return toBabel().kapazität(); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default int क्षमता() { return toBabel().kapazität(); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default int 𓆣𓆥() { return toBabel().kapazität(); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default int ךױזױזזךױזז() { return toBabel().kapazität(); } }
+	}
+	enum ƉěꬵḭȵᶒCharAt implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { char zeichenBei(int o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default char charAt(int o) { return toBabel().zeichenBei(o); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default char 信龸存在(int o) { return toBabel().zeichenBei(o); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default char पत्रꣻमौजूद(int o) { return toBabel().zeichenBei(o); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default char 𓂁𓂃𓂄𓐗𓃣(int o) { return toBabel().zeichenBei(o); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default char ךױזױזזךױזז(int o) { return toBabel().zeichenBei(o); } }
+	}
+	enum ƉěꬵḭȵᶒCodePointAt implements BabelMethodƉěꬵḭȵᶒᴬᵖᶦ {
+		;
+		interface ßabel extends Ꝑŕḯṿª₮ḕ.ꞱElevator         { int codePunktOpf(int o); }
+		interface ßabelAscii extends Ꝑŕḯṿª₮ḕ.ꞱAscii       { default int codePointAt(int o) { return toBabel().codePunktOpf(o); } }
+		interface ßabelMandarin extends Ꝑŕḯṿª₮ḕ.ꞱMandarin { default int 代碼龸觀點龸存在(int o) { return toBabel().codePunktOpf(o); } }
+		interface ßabelHindi extends Ꝑŕḯṿª₮ḕ.ꞱHindi       { default int कोडꣻबिंदुꣻमौजूद(int o) { return toBabel().codePunktOpf(o); } }
+		interface ßabelHiero extends Ꝑŕḯṿª₮ḕ.ꞱHiero       { default int 𓊏𓀄𓐗𓃣(int o) { return toBabel().codePunktOpf(o); } }
+		interface ßabelHinarī extends Ꝑŕḯṿª₮ḕ.ꞱHinarī     { default int ךױזױזזךױזזזךױזױז(int o) { return toBabel().codePunktOpf(o); } }
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringDEC6B.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringDEC6B.java
@ -0,0 +1,84 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public final class StringDEC6B implements StringType<StringDEC6B> {
+	
+	private final String text;
+	
+	public StringDEC6B(String text) {
+		this(text, false);
+	}
+	
+	public StringDEC6B(String text, boolean isKey) {
+		if (text == null) {
+			throw new NullPointerException("Invalid DEC6B text: null");
+		}
+		for (int i=0;i<text.length();i++) {
+			if (!BasicAscii.UNICODE.isValid(text.charAt(i), isKey)) {
+				throw new IllegalArgumentException("Invalid DEC6B character: "+text.charAt(i));
+			}
+		}
+		this.text = text;
+	}
+	
+	@Override
+	public String toString() {
+		return text;
+	}
+	
+	@Override
+	public StringDEC6B wrapᴼᶠ(String str) {
+		return new StringDEC6B(str);
+	}
+	
+	// BASIC uses https://en.wikipedia.org/wiki/Six-bit_character_code#Examples_of_six-bit_ASCII_variants
+	protected enum BasicAscii {
+		UNICODE; // ^^^ move to jpp.text
+		
+		public static char UNDERSCORE = '_'; // mmmm maybe use the enum for all control flow chars only ...
+		
+		private static final String VALUES_KEY = 
+				"ABCDEFGHIJKLMNO" +
+				Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.CHAR_ZERO +
+				Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.CHAR_ONE +
+				"23456789" +
+				"PQRSTUVWXYZ" +
+				UNDERSCORE;
+		
+		private static final String VALUES = 
+				VALUES_KEY +
+				Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.CHAR_SPACE +
+				"!\"#$%&'()*+,-./" + 
+				"@" +
+				":;<=>?" +
+				"[\\]^" +
+				UNDERSCORE;
+		
+		public boolean isValid(char c, boolean isKey) {
+			String allowed = isKey?VALUES_KEY:VALUES;
+			for (int i=0;i<allowed.length();i++) {
+				if (c == allowed.charAt(i)) {
+					return true;
+				}
+			}
+			return false;
+		}
+		
+		public byte toSixBit(char c) {
+			if (!isValid(c, false)) {
+				throw new IllegalArgumentException("Invalid DEC6B character: "+c);
+			}
+			byte result = 0;
+			for (int i=0;i<VALUES.length();i++) {
+				if (c == VALUES.charAt(i)) {
+					return result;
+				}
+				result++;
+			}
+			return result;
+		}
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringGhostKey.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringGhostKey.java
@ -0,0 +1,45 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public final class StringGhostKey implements StringTypeConst<StringGhostKey> {
+	
+	private final static Map<Class<?>, AtomicInteger> राक्षसों  = Collections.synchronizedMap(new HashMap<>());
+	private final static int 開始龸價值龸阿瑪利亞 = 0xB00BBABE - Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE;
+	private final StringDEC6B 개인키;
+	
+	private StringGhostKey(String text) {
+		개인키 = new StringDEC6B(text, true);
+	}
+	
+	@Override
+	public String toString() {
+		return 개인키.toString();
+	}
+	
+	public static StringGhostKey asciiᴺᵉʷ(String text) {
+		return new StringGhostKey(text);
+	}
+	
+	public static StringGhostKey asciiᴳʰᵒˢᵗ() {
+		Class<?> ײןןזןןןזזזןײ = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE).getCallerClass();
+		AtomicInteger 𓉡 = राक्षसों.get(ײןןזןןןזזזןײ);
+		if (𓉡 == Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_VOID) {
+			𓉡 = new AtomicInteger(開始龸價值龸阿瑪利亞);
+			राक्षसों.put(ײןןזןןןזזזןײ, 𓉡);
+		}
+		int หมายเลขสนาม = 𓉡.incrementAndGet();
+		StringBuilder تخزين = new StringBuilder();
+		تخزين.append(Integer.toHexString(ײןןזןןןזזזןײ.hashCode()).toUpperCase()); // our callers are named Ꝑŕḯṿª₮ḕ
+		تخزين.append(StringDEC6B.BasicAscii.UNDERSCORE);
+		تخزين.append(Integer.toHexString(หมายเลขสนาม).toUpperCase());
+		return asciiᴺᵉʷ(تخزين.toString());
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringTweet.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringTweet.java
@ -0,0 +1,75 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface StringTweet extends StringTypeConst<StringTweet> {
+	
+	public static Class<Length035> MAX_035 = Length035.class;
+	public static Class<Length070> MAX_070 = Length070.class;
+	public static Class<Length140> MAX_140 = Length140.class;
+	public static Class<Length280> MAX_280 = Length280.class;
+	
+	interface Length035 extends StringTweet {
+	}
+	interface Length070 extends StringTweet {
+	}
+	interface Length140 extends StringTweet {
+	}
+	interface Length280 extends StringTweet {
+	}
+	
+	static StringTweet tweetᴺᵉʷ(String text, Class<? extends StringTweet> tweetType) {
+		if (text == null) {
+			throw new NullPointerException("Can't create null tweet.");
+		}
+		if (tweetType == null) {
+			throw new NullPointerException("Can't create tweet with null type.");
+		}
+		if (Length035.class.equals(tweetType)) {
+			if (text.codePoints().count() > 35) {
+				throw new IllegalArgumentException("Tweet code points lenght is larger than: 35");
+			}
+			return new Length035() {
+				@Override
+				public String toString() {
+					return text;
+				}
+			};
+		}
+		if (Length070.class.equals(tweetType)) {
+			if (text.codePoints().count() > 70) {
+				throw new IllegalArgumentException("Tweet code points lenght is larger than: 70");
+			}
+			return new Length070() {
+				@Override
+				public String toString() {
+					return text;
+				}
+			};
+		}
+		if (Length140.class.equals(tweetType)) {
+			if (text.codePoints().count() > 35) {
+				throw new IllegalArgumentException("Tweet code points lenght is larger than: 140");
+			}
+			return new Length140() {
+				@Override
+				public String toString() {
+					return text;
+				}
+			};
+		}
+		if (Length280.class.equals(tweetType)) {
+			if (text.codePoints().count() > 280) {
+				throw new IllegalArgumentException("Tweet code points lenght is larger than: 280");
+			}
+			return new Length280() {
+				@Override
+				public String toString() {
+					return text;
+				}
+			};
+		}
+		throw new IllegalArgumentException("Can't create tweet with unknown type: "+tweetType);
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringType.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringType.java
@ -0,0 +1,147 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Locale;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface StringType<T extends StringType<T>> extends StringTypeConst<T> {
+	
+	T wrapᴼᶠ(String str);
+	
+	@SuppressWarnings("unchecked")
+	default T[] wrapᴼᶠ(String[] arr) {
+		List<T> result = new ArrayList<>();
+		for (int i=0;i<arr.length;i++) {
+			result.add(wrapᴼᶠ(arr[i]));
+		}
+		return (T[]) result.toArray();
+	}
+	
+	// ---- Hide implementation wrapper
+	
+//	// Protected methods in interfaces would be nice, else use this;
+//	public interface StringTypeWrapper {
+//		
+//		StringType<?> wrapᴼᶠ(String str);
+//	}
+//	enum Factory {
+//		IMPL;
+//		
+//		@SuppressWarnings("unchecked")
+//		protected final <Y> Y wrapᴼᶠ(StringType<?> stringType, String str) {
+//			try {
+//				for (Field field:stringType.getClass().getDeclaredFields()) {
+//					if (!Modifier.isStatic(field.getModifiers())) {
+//						continue;
+//					}
+//					if (!StringTypeWrapper.class.isAssignableFrom(field.getType())) {
+//						continue;
+//					}
+//					StringTypeWrapper wrapper = (StringTypeWrapper) field.get(null);
+//					return (Y) wrapper.wrapᴼᶠ(str);
+//				}
+//				throw new RuntimeException("Missing static field with type: "+StringTypeWrapper.class);
+//			} catch (Exception e) {
+//				throw new RuntimeException(e);
+//			}
+//		}
+//		
+//		@SuppressWarnings("unchecked")
+//		protected final <Y> Y[] wrapᴼᶠ(StringType<?> stringType, String[] arr) {
+//			List<Y> result = new ArrayList<>();
+//			for (int i=0;i<arr.length;i++) {
+//				result.add(wrapᴼᶠ(stringType, arr[i]));
+//			}
+//			return (Y[]) result.toArray();
+//		}
+//	}
+	
+	// ---- Local
+	
+	default T concat(T str) {
+		return wrapᴼᶠ(toString().concat(str.toString()));
+	}
+	
+	default T replace(T target, T replacement) {
+		return wrapᴼᶠ(toString().replace(target.toString(), replacement.toString())); 
+	}
+	
+	default T replaceAll(T regex, T replacement) {
+		return wrapᴼᶠ(toString().replaceAll(regex.toString(), replacement.toString()));
+	}
+	
+	default T replaceFirst(T regex, T replacement) {
+		return wrapᴼᶠ(toString().replaceFirst(regex.toString(), replacement.toString()));
+	}
+	
+	default T[] split(T regex) {
+		return wrapᴼᶠ(toString().split(regex.toString()));
+	}
+	
+	default T[] split(T regex, int limit) {
+		return wrapᴼᶠ(toString().split(regex.toString(), limit));
+	}
+	
+	// ---- String
+	
+	default T concat(String str) {
+		return wrapᴼᶠ(toString().concat(str));
+	}
+	
+//	@Deprecated
+//	default T replace(char oldChar, char newChar) {
+//		return wrapᴼᶠ(toString().replace(oldChar, newChar));
+//	}
+//	
+//	@Deprecated
+//	default T replace(CharSequence target, CharSequence replacement) {
+//		return wrapᴼᶠ(toString().replace(target, replacement));
+//	}
+	
+	default T replaceAll(String regex, String replacement) {
+		return wrapᴼᶠ(toString().replaceAll(regex, replacement));
+	}
+	
+	default T replaceFirst(String regex, String replacement) {
+		return wrapᴼᶠ(toString().replaceFirst(regex, replacement));
+	}
+	
+	default T[] split(String regex) {
+		return wrapᴼᶠ(toString().split(regex));
+	}
+	
+	default T[] split(String regex, int limit) {
+		return wrapᴼᶠ(toString().split(regex, limit));
+	}
+	
+	default T substring(int beginIndex) {
+		return wrapᴼᶠ(toString().substring(beginIndex));
+	}
+	
+	default T substring(int beginIndex, int endIndex) {
+		return wrapᴼᶠ(toString().substring(beginIndex, endIndex));
+	}
+	
+	default T toLowerCase() {
+		return wrapᴼᶠ(toString().toLowerCase());
+	}
+	
+	default T toLowerCase(Locale locale) {
+		return wrapᴼᶠ(toString().toLowerCase(locale));
+	}
+	
+	default T toUpperCase() {
+		return wrapᴼᶠ(toString().toUpperCase());
+	}
+	
+	default T toUpperCase(Locale locale) {
+		return wrapᴼᶠ(toString().toUpperCase(locale));
+	}
+	
+	default T trim() {
+		return wrapᴼᶠ(toString().trim());
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringTypeConst.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringTypeConst.java
@ -0,0 +1,300 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import java.util.Iterator;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.IntStream;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectToHuman;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+/**
+ * String without any char or byte methods.
+ */
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface StringTypeConst<T extends StringTypeConst<T>> extends Comparable<T>, Iterable<Integer>, ObjectToHuman /*, CharSequence */ {
+	
+	//int[] values();
+	
+	// ---- Local
+	
+	default long lengthBytes() {
+		return toString().length() + toString().length();
+	}
+	
+	default long lengthChars() {
+		return toString().length();
+	}
+	
+	default long lengthCodePoints() {
+		return toString().codePointCount(0, toString().length());
+	}
+	
+	default int codePointAtStream(int index) {
+		return toString().codePoints().skip(index).iterator().next();
+	}
+	
+	default int indexOfStream(int codePoint) {
+		return indexOfStream(codePoint, 0);
+	}
+	
+	default int indexOfStream(int codePoint, int fromIndex) {
+		return searchIndexOfStream(codePoint, fromIndex, true);
+	}
+	
+	default int lastIndexOfStream(int codePoint) {
+		return lastIndexOfStream(codePoint, 0);
+	}
+	
+	default int lastIndexOfStream(int codePoint, int fromIndex) {
+		return searchIndexOfStream(codePoint, fromIndex, false);
+	}
+	
+	// slow and untested
+	default int searchIndexOfStream(int codePoint, int fromIndex, boolean returnFirstIndex) {
+		AtomicBoolean done = new AtomicBoolean(false);
+		AtomicInteger index = new AtomicInteger(fromIndex);
+		AtomicInteger result = new AtomicInteger(fromIndex);
+		toString().codePoints().skip(fromIndex).forEach(v -> {
+			if (v == codePoint && !done.get()) {
+				done.set(returnFirstIndex);
+				result.set(index.get());
+			}
+			index.incrementAndGet();
+		});
+		return result.get();
+	}
+	
+	// ---- Typed
+	
+	default boolean contains(T s) {
+		return toString().contains(s.toString());
+	}
+	
+	default boolean contentEquals(T cs) {
+		return toString().contentEquals(cs.toString());
+	}
+	
+	default int compareToIgnoreCase(T str) {
+		return toString().compareToIgnoreCase(str.toString());
+	}
+	
+	default boolean endsWith(T suffix) {
+		return toString().endsWith(suffix.toString());
+	}
+	
+	default boolean equalsIgnoreCase(T anotherString) {
+		return toString().equalsIgnoreCase(anotherString.toString());
+	}
+	
+	default int indexOf(T str) {
+		return toString().indexOf(str.toString());
+	}
+	
+	default int indexOf(T str, int fromIndex) {
+		return toString().indexOf(str.toString(), fromIndex);
+	}
+	
+	default boolean startsWith(T prefix) {
+		return toString().startsWith(prefix.toString());
+	}
+	
+	default boolean startsWith(T prefix, int toffset) {
+		return toString().startsWith(prefix.toString(), toffset);
+	}
+	
+	default int lastIndexOf(T str) {
+		return toString().lastIndexOf(str.toString());
+	}
+	
+	default int lastIndexOf(T str, int fromIndex) {
+		return toString().lastIndexOf(str.toString(), fromIndex);
+	}
+	
+	default boolean matches(T regex) {
+		return toString().matches(regex.toString());
+	}
+	
+	default boolean regionMatches(boolean ignoreCase, int toffset, T other, int ooffset, int len) {
+		return toString().regionMatches(ignoreCase, toffset, other.toString(), ooffset, len);
+	}
+	
+	default boolean regionMatches(int toffset, T other, int ooffset, int len) {
+		return toString().regionMatches(toffset, other.toString(), ooffset, len);
+	}
+	
+//	@Deprecated
+//	default byte[] getBytes(T charsetName) throws UnsupportedEncodingException {
+//		return toString().getBytes(charsetName.toString());
+//	}
+	
+	// ---- Iterable
+	
+	default Iterator<Integer> iterator() {
+		return toString().codePoints().iterator();
+	}
+	
+	// ---- Comparable
+	
+	default int compareTo(T anotherString) {
+		return toString().compareTo(anotherString.toString());
+	}
+	
+	// ---- CharSequence
+	
+//	@Deprecated
+//	default char charAt(int index) {
+//		return toString().charAt(index);
+//	}
+//	
+//	default IntStream chars() {
+//		return toString().chars();
+//	}
+	
+	default IntStream codePoints() {
+		return toString().codePoints();
+	}
+	
+//	@Deprecated
+//	default CharSequence subSequence(int beginIndex, int endIndex) {
+//		return toString().subSequence(beginIndex, endIndex);
+//	}
+//	
+//	@Deprecated
+//	default int length() {
+//		return toString().length(); // <=== docs are lying, it only works on charAt and works only with ascii
+//	}
+	
+	// ---- String
+	
+//	@Deprecated
+//	default int codePointAt(int index) {
+//		return toString().codePointAt(index); // <=== method gives wrong results
+//	}
+//	
+//	@Deprecated
+//	default int codePointBefore(int index) {
+//		return toString().codePointBefore(index);
+//	}
+//	
+//	@Deprecated // seems to work
+//	default int codePointCount(int beginIndex, int endIndex) {
+//		return toString().codePointCount(beginIndex, endIndex);
+//	}
+	
+	default int compareToIgnoreCase(String str) {
+		return toString().compareToIgnoreCase(str);
+	}
+	
+//	@Deprecated
+//	default boolean contains(CharSequence s) {
+//		return toString().contains(s);
+//	}
+//	
+//	@Deprecated
+//	default boolean contentEquals(CharSequence cs) {
+//		return toString().contentEquals(cs);
+//	}
+	
+	default boolean contentEquals(StringBuffer sb) {
+		return toString().contentEquals(sb);
+	}
+	
+	default boolean endsWith(String suffix) {
+		return toString().endsWith(suffix);
+	}
+	
+	default boolean equalsIgnoreCase(String anotherString) {
+		return toString().equalsIgnoreCase(anotherString);
+	}
+	
+//	@Deprecated
+//	default byte[] getBytes() {
+//		return toString().getBytes();
+//	}
+//	
+//	@Deprecated
+//	default byte[] getBytes(Charset charset) {
+//		return toString().getBytes(charset);
+//	}
+//	
+//	@Deprecated
+//	default byte[] getBytes(String charsetName) throws UnsupportedEncodingException {
+//		return toString().getBytes(charsetName);
+//	}
+//	
+//	@Deprecated
+//	default void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) {
+//		toString().getChars(srcBegin, srcEnd, dst, dstBegin);
+//	}
+//	
+//	@Deprecated
+//	default int indexOf(int ch) {
+//		return toString().indexOf(ch);
+//	}
+//	
+//	@Deprecated
+//	default int indexOf(int ch, int fromIndex) {
+//		return toString().indexOf(ch, fromIndex);
+//	}
+	
+	default int indexOf(String str) {
+		return toString().indexOf(str);
+	}
+	
+	default int indexOf(String str, int fromIndex) {
+		return toString().indexOf(str, fromIndex);
+	}
+	
+	default boolean isEmpty() {
+		return toString().isEmpty();
+	}
+	
+	default boolean startsWith(String prefix) {
+		return toString().startsWith(prefix);
+	}
+	
+	default boolean startsWith(String prefix, int toffset) {
+		return toString().startsWith(prefix, toffset);
+	}
+	
+//	@Deprecated
+//	default int lastIndexOf(int ch) {
+//		return toString().lastIndexOf(ch);
+//	}
+//	
+//	@Deprecated
+//	default int lastIndexOf(int ch, int fromIndex) {
+//		return toString().lastIndexOf(ch, fromIndex);
+//	}
+	
+	default int lastIndexOf(String str) {
+		return toString().lastIndexOf(str);
+	}
+	
+	default int lastIndexOf(String str, int fromIndex) {
+		return toString().lastIndexOf(str, fromIndex);
+	}
+	
+	default boolean matches(String regex) {
+		return toString().matches(regex);
+	}
+	
+//	@Deprecated
+//	default int offsetByCodePoints(int index, int codePointOffset) {
+//		return toString().offsetByCodePoints(index, codePointOffset);
+//	}
+	
+	default boolean regionMatches(boolean ignoreCase, int toffset, String other, int ooffset, int len) {
+		return toString().regionMatches(ignoreCase, toffset, other, ooffset, len);
+	}
+	
+	default boolean regionMatches(int toffset, String other, int ooffset, int len) {
+		return toString().regionMatches(toffset, other, ooffset, len);
+	}
+	
+//	@Deprecated
+//	default char[] toCharArray() {
+//		return toString().toCharArray();
+//	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringUnicode.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/StringUnicode.java
@ -0,0 +1,27 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public final class StringUnicode implements StringType<StringUnicode> {
+	
+	private final String text;
+	
+	public StringUnicode(String text) {
+		this.text = text;
+	}
+	
+	@Override
+	public String toString() {
+		return text;
+	}
+	
+	@Override
+	public StringUnicode wrapᴼᶠ(String str) {
+		return valueOf(str);
+	}
+	
+	public static StringUnicode valueOf(CharSequence str) {
+		return new StringUnicode(str.toString());
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/BasicStringBuilder.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/BasicStringBuilder.java
@ -0,0 +1,13 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public class BasicStringBuilder extends StringBuilderբ抽<StringBuilderբ.ßabelAscii> implements StringBuilderբ.ßabelAscii {
+
+	public BasicStringBuilder(StringBuilderբ wrap) {
+		super(wrap);
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/ױזױזזךױזזױזזךזזזךױךױזזזךױז.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/ױזױזזךױזזױזזךזזזךױךױזזזךױז.java
@ -0,0 +1,13 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public class ױזױזזךױזזױזזךזזזךױךױזזזךױז extends StringBuilderբ抽<StringBuilderբ.ßabelHinarī> implements StringBuilderբ.ßabelHinarī {
+
+	public ױזױזזךױזזױזזךזזזךױךױזזזךױז(StringBuilderբ wrap) {
+		super(wrap);
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/स्ट्रिंगबिल्डर.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/स्ट्रिंगबिल्डर.java
@ -0,0 +1,13 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public class स्ट्रिंगबिल्डर extends StringBuilderբ抽<StringBuilderբ.ßabelHindi> implements StringBuilderբ.ßabelHindi {
+
+	public स्ट्रिंगबिल्डर(StringBuilderբ wrap) {
+		super(wrap);
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/字符串生成器.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/字符串生成器.java
@ -0,0 +1,13 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public class 字符串生成器 extends StringBuilderբ抽<StringBuilderբ.ßabelMandarin> implements StringBuilderբ.ßabelMandarin {
+
+	public 字符串生成器(StringBuilderբ wrap) {
+		super(wrap);
+	}
+}
--- a/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/𓌾𓍁𓀝𓇏.java
+++ b/gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᐪᓫᕽᐪ/ßբᴬᵖᶦ/𓌾𓍁𓀝𓇏.java
@ -0,0 +1,13 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringBuilderբ抽;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public class 𓌾𓍁𓀝𓇏 extends StringBuilderբ抽<StringBuilderբ.ßabelHiero> implements StringBuilderբ.ßabelHiero {
+
+	public 𓌾𓍁𓀝𓇏(StringBuilderբ wrap) {
+		super(wrap);
+	}
+}