Converted to correct J letter

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/Bãß.java

@@ -0,0 +1,389 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ;
+
+import java.lang.instrument.Instrumentation;
+import java.lang.reflect.InvocationTargetException;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.WeakHashMap;
+import java.util.concurrent.locks.Lock;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytsFlüstern注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnExport注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffin;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinDuytschenᵗˣᵗ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinGhost;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinGhostSpell;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinGhostSpellLock;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpider;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderSperm;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ邪ᙾ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.Runnableբ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer邪ᙾ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocConstructor注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocMethod注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocType注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDoc注;
+import ᒢᐩᐩ.ᔿᐤᒄʸ.ᒢᔿᕽ.CounterGuageᴶᴹˣ;
+import ᒢᐩᐩ.ᔿᐤᒄʸ.ᒼᐤᣕᒼᓑᣗᣗᓫᣕᐪ.DummyReadWriteLock;
+import ᒢᐩᐩ.ᔿᐤᒄʸ.ᣔᒃᣔᒼᓑᔆ.BãßBȍőnAbacusInstanceMBeanʸᴰ;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@DuytsDocType注(babel = {
+		@DuytsDoc注(locale= "en", purpose = "Runtime for static bass noise ௸.."),
+		@DuytsDoc注(locale= "zh", code = "低音", purpose = "來自天堂的靜態低音噪音的運行時間"),
+		@DuytsDoc注(locale= "hi", code = "बास", purpose = "स्वर्ग से स्थिर बास शोर के लिए रनटाइम")
+})
+public interface Bãß {
+	
+	@DuytsDocType注(babel = {
+			@DuytsDoc注(locale= "en", code = "lijkenkistʸᴰ", purpose = "Sarcophagus aggregates Y-Dimensions"),
+			@DuytsDoc注(locale= "zh", purpose = "石棺聚合多個維度"),
+			@DuytsDoc注(locale= "hi", code = "पत्थरꣻकीꣻबनीꣻहुईꣻकब्रʸᴰ", purpose = "सरकोफैगस कई आयामों को एकत्रित करता है")
+	})
+	@BãßBȍőnExport注(group = "love.distributedrebirth.bassboon")
+	@BãßBȍőnDuytsFlüstern注(purpose = "RM ME")
+	static enum 石棺ʸᴰ implements BãßBȍőnAbacusInstanceMBeanʸᴰ<石棺ʸᴰ> {
+		أَكْبَرײꣻײالله;
+		private final Map<Object, BȍőnGrave> יְרוּשָׁלַיִםᒾ = new WeakHashMap<>();
+		private final List<BãßBȍőnSpiderSperm> സ്പൈഡർബീജം = Bãß.характеристики.熱蘭遮城.ןװיזױזזךזדןװיױןױדודו();
+		private final 𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ 𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨 = Bãß.характеристики.熱蘭遮城.ןיװיזױױדודזיןןןזךױזזז();
+		private final ReadWriteLock 魎 = Bãß.характеристики.熱蘭遮城.ןיװיןזךױזױדזיןןזזזױדו();
+		private final Lock 魎_いい人生 = 魎.readLock(); // mononoke good life
+		private final Lock 魎_שמירה = 魎.writeLock(); // mononoke death guard
+		@BãßBȍőnSpiderWire注(name = "boonCntInit")
+		private CounterGuageᴶᴹˣ boonCntInit = new CounterGuageᴶᴹˣ("init", "only"); // TODO: fix to protected so this is not possible...
+		@BãßBȍőnSpiderWire注(name = "boonCntInit")
+		private CounterGuageᴶᴹˣ boonCntLock = new CounterGuageᴶᴹˣ("init", "only");
+		@BãßBȍőnSpiderWire注(name = "bassCntSpiderEmbryos")
+		private CounterGuageᴶᴹˣ bassCntSpiderEmbryos = new CounterGuageᴶᴹˣ("init", "only");
+		@BãßBȍőnSpiderWire注(name = "bassCntCoffinToGrave")
+		private CounterGuageᴶᴹˣ bassCntCoffinToGrave = new CounterGuageᴶᴹˣ("init", "only");
+		@BãßBȍőnSpiderWire注(name = "bassCntDigToGrave")
+		private CounterGuageᴶᴹˣ bassCntDigToGrave = new CounterGuageᴶᴹˣ("init", "only");
+		@BãßBȍőnSpiderWire注(name = "bassCntCoffinBurried")
+		private CounterGuageᴶᴹˣ bassCntCoffinBurried = new CounterGuageᴶᴹˣ("init", "only");
+		private Runnableբ.जंगम Г̄Ѫӏ = () -> {
+			// self first boot, one time only without if statements...
+			Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.挖ᵀᵒ(Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله).init(Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله); // just compile again until it works....
+			Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.Г̄Ѫӏ = () -> boonCntInit.increment();
+		};
+		
+		@DuytsDocConstructor注(babel = {
+				@DuytsDoc注(locale= "en", purpose = "Sarcophagus is closed for humans"),
+				@DuytsDoc注(locale= "zh", purpose = "石棺對人類關閉"),
+				@DuytsDoc注(locale= "hi", purpose = "सरकोफैगस इंसानों के लिए बंद है")
+		})
+		private 石棺ʸᴰ() {
+			Bãß.характеристики.熱蘭遮城.יזזןיזךױױזזױ = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.CHAR_ATARI > Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ZERO;
+		}
+		
+		@DuytsDocMethod注(babel = {
+				@DuytsDoc注(locale= "en", code = "boonInit", purpose = "RÅ...........Init"),
+				@DuytsDoc注(locale= "zh", code = "恩惠初始化", purpose = "拉布恩飛行"),
+				@DuytsDoc注(locale= "hi", code = "बूनꣻस्टार्ट", purpose = "रा बून फ्लाइंग")
+		})
+		public <T extends BãßBȍőnʸᴰ<T>> void 𓂀ױןייזדזיודזיןןזזזןױ𓉢(BãßBȍőnʸᴰ<T> derKnochen) {
+			//boonCntInit.increment();
+			Г̄Ѫӏ.दौड़ना();
+			挖ᵀᵒ(derKnochen).init(derKnochen);
+		}
+		
+		@DuytsDocMethod注(babel = {
+				@DuytsDoc注(locale= "en", code = "lockGrave", purpose = "Closes the coffin so no new ghosts can enter"),
+				@DuytsDoc注(locale= "zh", code = "墳墓鎖", purpose = "關上棺材，讓新的鬼魂無法進入"),
+				@DuytsDoc注(locale= "hi", code = "कब्रꣻकाꣻताला", purpose = "ताबूत को बंद कर देता है ताकि कोई नया भूत प्रवेश न कर सके")
+		})
+		public <T extends BãßBȍőnʸᴰ<T>> void 墳ᴸᵒᶜᵏ(BãßBȍőnʸᴰ<T> derKnochen) {
+			boonCntLock.increment();
+			挖ᵀᵒ(derKnochen).lock(derKnochen);
+		}
+		
+		@DuytsDocMethod注(babel = {
+				@DuytsDoc注(locale= "en", code = "spiderEmbryoAdd", purpose = "Injection of external spider sperm to mix the dead bones"),
+				@DuytsDoc注(locale= "zh", code = "蜘蛛胚胎添加", purpose = "注射外部蜘蛛精混合死骨"),
+				@DuytsDoc注(locale= "hi", code = "मकड़ीꣻभ्रूणꣻजोड़ें", purpose = "मृत हड्डियों को मिलाने के लिए बाहरी मकड़ी के शुक्राणु का इंजेक्शन")
+		})
+		public void 蜘蛛胚ᴬᵈᵈ(BãßBȍőnSpiderSperm spinneSperma) {
+			bassCntSpiderEmbryos.increment();
+			സ്പൈഡർബീജം.add(spinneSperma);
+		}
+		
+		@DuytsDocMethod注(babel = {
+				@DuytsDoc注(locale= "en", code = "coffinOf", purpose = "Gets the coffin from the grave"),
+				@DuytsDoc注(locale= "zh", code = "棺材", purpose = "從墳墓中取出棺材"),
+				@DuytsDoc注(locale= "hi", code = "काꣻताबूत", purpose = "कब्र से ताबूत मिलता है")
+		})
+		protected <T extends BãßBȍőnʸᴰ<T>> BãßBȍőnCoffin 棺ᴼᶠ(BãßBȍőnʸᴰ<T> derKnochen) {
+			bassCntCoffinToGrave.increment();
+			return 挖ᵀᵒ(derKnochen);
+		}
+		protected <T extends BãßBȍőnʸᴰ<T>, G extends BãßBȍőnCoffinDuytschenᵗˣᵗ> G 棺ᴼᶠ(BãßBȍőnʸᴰ<T> derKnochen, Class<G> duytschen) {
+			bassCntCoffinToGrave.increment();
+			return 挖ᵀᵒ(derKnochen).ₜₒI18Nᵗˣᵗ(duytschen);
+		}
+		
+		/**
+		 * Dig To
+		 */
+		private <T extends BãßBȍőnʸᴰ<T>> BȍőnGrave 挖ᵀᵒ(BãßBȍőnʸᴰ<T> derKnochen) {
+			bassCntDigToGrave.increment();
+			BȍőnGrave 𓁀 = null;
+			魎_いい人生.lock();
+			try {
+				𓁀 = יְרוּשָׁלַיִםᒾ.get(derKnochen);
+			} finally {
+				魎_いい人生.unlock();
+			}
+			if (𓁀 == null) {
+				魎_שמירה.lock();
+				try {
+					𓁀 = new BȍőnGrave(𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨, സ്പൈഡർബീജം);
+					יְרוּשָׁלַיִםᒾ.put(derKnochen, 𓁀);
+				} finally {
+					魎_שמירה.unlock();
+				}
+				bassCntCoffinBurried.increment();
+			}
+			return 𓁀;
+		}
+		/*
+		public static <T> BeanWrapper<T> 豆ᴺᴱᵂ(Class<T> seedling) { // bean-new
+			try {
+				T bean = seedling.getConstructor().newInstance();
+				if (bean instanceof BãßBȍőnʸᴰ) {
+					BãßBȍőnʸᴰ<?> boon = (BãßBȍőnʸᴰ<?>) bean;
+					BȍőnGrave grave = 墳ᴼᶠ(boon);
+					if (!grave.inited) {
+						魎ᴵᴺᴵᵀ(boon);
+					}
+					return new BeanWrapper<>(bean);
+				}
+				return new BeanWrapper<>(bean);
+			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+					| InvocationTargetException | NoSuchMethodException | SecurityException e) {
+				throw new RuntimeException(e);
+			}
+		}
+		
+		public static final class BeanWrapper<T> implements DefaultBãßBȍőnʸᴰ<T>, BãßBȍőnSpiderCloak<T> {
+			private final T bean;
+			
+			private BeanWrapper(T bean) {
+				魎ᴵᴺᴵᵀ(this);
+				this.bean = bean;
+			}
+			
+			@Override
+			public T getBean() {
+				return bean;
+			}
+		}
+		*/
+		private static final class BȍőnGrave implements BãßBȍőnCoffin {
+			private final Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> duytschenCoffins = new HashMap<>();
+			private final Map<Class<?>,BãßBȍőnCoffinGhost> ghosts = new HashMap<>();
+			private final 𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ 𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨;
+			private final BãßBȍőnSpider spider;
+			private boolean inited = false;
+			private boolean locked = false;
+			
+			private BȍőnGrave(𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ 𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨, List<BãßBȍőnSpiderSperm> spiderSperm) {
+				this.𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨 = 𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨;
+				spider = new BãßBȍőnSpider(spiderSperm);
+				BãßBȍőnCoffinDuytschenᵗˣᵗ.ײₚᵤₜI18Nᵗˣᵗײ(duytschenCoffins, this);
+			}
+			
+			private <T extends BãßBȍőnʸᴰ<T>> void init(BãßBȍőnʸᴰ<T> derKnochen) {
+				if (inited) {
+					return;
+				}
+				𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨.𝔦𝔫𝔦𝔱𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(derKnochen, spider, duytschenCoffins);
+				inited = true;
+			}
+			
+			private <T extends BãßBȍőnʸᴰ<T>> void lock(BãßBȍőnʸᴰ<T> derKnochen) {
+				if (locked) {
+					return;
+				}
+				𝔪𝔬𝔬𝔫𝔖𝔭𝔢𝔩𝔩𝔚𝔬𝔯𝔨.𝔩𝔬𝔠𝔨𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(derKnochen, spider);
+				for (Class<?> familyName:new ArrayList<>(ghosts.keySet())) {
+					BãßBȍőnCoffinGhost ghost = ghosts.get(familyName);
+					ghosts.put(familyName, BãßBȍőnCoffinGhostSpellLock.castᴼᶠ(ghost).LOCK());
+				}
+				locked = true;
+			}
+			
+			@Override
+			public BãßBȍőnCoffinGhost UNHOLY(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName) {
+				BãßBȍőnCoffinGhost ghost = ghosts.get(familyName);
+				if (ghost == null) {
+					if (locked) {
+						throw new RuntimeException("Coffin locked");
+					}
+					ghost = BãßBȍőnCoffinGhostSpellLock.instanceᴺᵉʷ();
+					ghosts.put(familyName, ghost);
+				}
+				return ghost;
+			}
+			
+			@Override
+			public BãßBȍőnCoffinGhostSpell UNHOLY_SPELL(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName) {
+				return BãßBȍőnCoffinGhostSpell.castᴼᶠ(UNHOLY(familyName));
+			}
+			
+			@SuppressWarnings("unchecked")
+			@Override
+			public <T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T NOISE_OF(Class<T> noiseName) {
+				try {
+					return (T) spider.silkRoad(noiseName).senseWire(null, null, null); // rm args...
+				} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
+					throw new RuntimeException(e);
+				}
+			}
+			
+			@SuppressWarnings("unchecked")
+			private <G extends BãßBȍőnCoffinDuytschenᵗˣᵗ> G ₜₒI18Nᵗˣᵗ(Class<G> duytschen) {
+				G result = (G) duytschenCoffins.get(duytschen);
+				if (result == null) {
+					throw new IllegalArgumentException("Unknown duytschen: "+duytschen);
+				}
+				return result;
+			}
+		}
+	}
+	
+	//member static final class ℭỗᶇṧⱦᶏꬼȶʂ { // todo: jvm add death to "import static" name space pollution.
+	public static final class ℭỗᶇṧⱦᶏꬼȶʂ {
+		// 4 is magnetic consent and 3 is forced stable outcome
+		public static final char CHAR_ZERO = '0';  // nothing
+		public static final char CHAR_ONE = '1';   // all
+		public static final char CHAR_SPACE = ' '; // eatherspace
+		public static final char CHAR_ATARI = 'a'; // corner stone of creation 𐦠𐦴𐦫𐦢
+		// the nether
+		public static final String STR_ZERO = "0";  //String.valueOf(CHAR_ZERO);
+		public static final String STR_ONE = "1";   //String.valueOf(CHAR_ONE);
+		public static final String STR_EMPTY = "";  //STR_ONE.substring(Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE);
+		public static final String STR_SPACE = " "; //String.valueOf(CHAR_SPACE);
+		// red
+		public static final int INT_ZERO = 0; //Integer.valueOf(STR_ZERO);
+		public static final int INT_ONE = 1;  //Integer.valueOf(STR_ONE);
+		public static final int INT_TEN = 10; //Integer.valueOf(STR_ONE+STR_ZERO);
+		// white
+		public static final long LONG_ZERO = 0l; //Long.valueOf(STR_ZERO);
+		public static final long LONG_ONE = 1l;  //Long.valueOf(STR_ONE);
+		public static final long LONG_TEN = 10l; //Long.valueOf(STR_ONE+STR_ZERO);
+		// blue
+		public static final float FLOAT_ZERO = 0f; //Float.valueOf(STR_ZERO);
+		public static final float FLOAT_ONE = 1f;  //Float.valueOf(STR_ONE);
+		public static final float FLOAT_TEN = 10f; //Float.valueOf(STR_ONE+STR_ZERO);
+		// orange on top
+		public static final double DOUBLE_ZERO = 0d; //Double.valueOf(STR_ZERO);
+		public static final double DOUBLE_ONE = 1f;  //Double.valueOf(STR_ONE);
+		public static final double DOUBLE_TEN = 10f; //Double.valueOf(STR_ONE+STR_ZERO);
+		// and a bipolar flag pole
+		public static final Object PTR_VOID = null;
+		public static final Object PTR_OBJECT = new ℭỗᶇṧⱦᶏꬼȶʂ();
+		// private is public ^^^
+		private ℭỗᶇṧⱦᶏꬼȶʂ() {
+		}
+		// ...
+		// ...
+		// ...
+	}
+	
+	interface 𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ {
+		
+		<T extends BãßBȍőnʸᴰ<T>> void 𝔩𝔬𝔠𝔨𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider);
+		
+		<T extends BãßBȍőnʸᴰ<T>> void 𝔦𝔫𝔦𝔱𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider, Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> duytschenCoffins);
+	}
+	
+	// characteristics
+	enum характеристики { 
+		熱蘭遮城;
+		
+		private boolean יזזןיזךױױזזױ = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_VOID == Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_OBJECT;
+		private boolean יזױזװיךןךױזױ = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_VOID != Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_OBJECT;
+		private Class<𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ> ןיװיךזדודיזןיןןזױיזזךױױז;
+		
+		private void ױזדיןזךזןיןױז() {
+			if (יזזןיזךױױזזױ) {
+				throw new װошибкаיзапускаיракетыװ("יזזןיזךױױזזױ");
+			}
+		}
+		
+		public void ױזךיךזװןיןיןןזױז() {
+			ױזדיןזךזןיןױז();
+			יזױזװיךןךױזױ = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_VOID == Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_OBJECT;
+		}
+		
+		public void ױזךױזזװיךז(Class<𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ> ןיװיךזדודיזןיןןזױיזזךױױז) {
+			ױזדיןזךזןיןױז();
+			this.ןיװיךזדודיזןיןןזױיזזךױױז = ןיװיךזדודיזןיןןזױיזזךױױז;
+		}
+		
+		protected 𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ ןיװיזױױדודזיןןןזךױזזז() {
+			ױזדיןזךזןיןױז();
+			if (ןיװיךזדודיזןיןןזױיזזךױױז == Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.PTR_VOID) {
+				return new DefaultBȍőnLoader();
+			} else {
+				try {
+					return ןיװיךזדודיזןיןןזױיזזךױױז.getConstructor().newInstance();
+				} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
+						| InvocationTargetException | NoSuchMethodException | SecurityException e) {
+					throw new װошибкаיзапускаיракетыװ(e);
+				}
+			}
+		}
+		
+		protected ReadWriteLock ןיװיןזךױזױדזיןןזזזױדו() {
+			ױזדיןזךזןיןױז();
+			if (יזױזװיךןךױזױ) {
+				return new ReentrantReadWriteLock();
+			}
+			return new DummyReadWriteLock();
+		}
+		
+		protected <K,V> Map<K,V> ןיזזױזזךױװיןװיןױדזיװיךזדודו() {
+			ױזדיןזךזןיןױז();
+			if (יזױזװיךןךױזױ) {
+				return Collections.synchronizedMap(new HashMap<>());
+			}
+			return new HashMap<>();
+		}
+		
+		protected <T> List<T> ןװיזױזזךזדןװיױןױדודו() {
+			ױזדיןזךזןיןױז();
+			if (יזױזװיךןךױזױ) {
+				return Collections.synchronizedList(new ArrayList<>());
+			}
+			return new ArrayList<>();
+		}
+		
+		protected static class װошибкаיзапускаיракетыװ extends RuntimeException {
+			private static final long serialVersionUID = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.LONG_ONE;
+			protected װошибкаיзапускаיракетыװ(Exception err) {
+				super(err);
+			}
+			protected װошибкаיзапускаיракетыװ(String msg) {
+				super(msg);
+			}
+			enum 邪ᙾ {
+				;
+				public static void agentmain(String agentArgs, Instrumentation inst) {// test
+					inst.addTransformer(new BabelLocalizer邪ᙾ(), true);
+					inst.addTransformer(new ObjectScopeLimitΔ邪ᙾ(), true);
+				}
+			}
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/BãßBȍőnʸᴰ.java

@@ -0,0 +1,30 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+//publicinterfaceBãßBȍőnʸᴰ<T⁽⁾> { // TODO: jvm recursive terminator² type sugar
+public interface BãßBȍőnʸᴰ<T extends BãßBȍőnʸᴰ<T>> {
+	
+	@SuppressWarnings("unchecked")
+	default T toBȍőn() {
+		return (T)this; // allow builders...
+	}
+	
+//	default <G extends BãßBȍőnCoffinDuytschenᵗˣᵗ> G toBȍőnGrab(Class<G> duytschen) {
+//		return Bãß.石棺ʸᴰ.棺ᴼᶠ(this, duytschen);
+//	}
+//	
+//	default BãßBȍőnCoffinGhost toBȍőnGrabGeist(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ<?>> familyName) {
+//		return toBȍőnGrab(BãßBȍőnCoffinDuytschenᵗˣᵗ.𓃬𓍄𓋹𓀭.class).𓆙𓄿𓏀𓃟𓇋𓇋𓄋(familyName);
+//	}
+	
+	default BãßBȍőnCoffin toBBC() {
+		return Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.棺ᴼᶠ(this); // ...to seek 6 bit BASIC death, so the blind can see
+	}
+	
+//	static BãßBȍőnCoffin coffinOf(BãßBȍőnʸᴰ<?> boon) {
+//		return Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.棺ᴼᶠ(boon);
+//	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/DefaultBãßBȍőnʸᴰ.java

@@ -0,0 +1,19 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnAnnotationʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnAuthorʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytsFlüsternʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnExportʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface DefaultBãßBȍőnʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends
+	BãßBȍőnʸᴰ<T>,
+	BãßBȍőnPirateʸᴰ<T>,
+	BãßBȍőnDuytsFlüsternʸᴰ<T>,
+	BãßBȍőnAuthorʸᴰ<T>,
+	BãßBȍőnExportʸᴰ<T>,
+	BãßBȍőnAnnotationʸᴰ<T>
+	{
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/DefaultBȍőnLoader.java

@@ -0,0 +1,258 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ;
+
+import java.lang.annotation.Annotation;
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhaseBarrier注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinDuytschenᵗˣᵗ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpider;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderEgg注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderSilk;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public final class DefaultBȍőnLoader implements Bãß.𝔅𝔬𝔫𝔢𝔏𝔬𝔞𝔡𝔢𝔯ʸᴰ {
+	
+	protected DefaultBȍőnLoader() {
+	}
+	
+	public <T extends BãßBȍőnʸᴰ<T>> void 𝔩𝔬𝔠𝔨𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider) {
+		try {
+			List<PiratePhaseBoat> filoBoats = loadPirateBoats(boon);// TODO: run from spider objects...
+			Collections.reverse(filoBoats);
+			
+//			Set<Class<?>> ydmods = new HashSet<>();
+			for (PiratePhaseBoat boat : filoBoats) {
+//				if (ydmods.add(boat.pirateClazz.getDeclaringClass())) {
+//					spider.registrateEgg(boat.pirateClazz.getDeclaringClass(), new BãßBȍőnSpiderSilk() {
+//						@Override
+//						public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
+//								throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+//							return boonTmp;
+//						}
+//					});
+//				}
+				//registrateSpiderEggs(boat.pirateClazz, spider, boat.pirate);
+				initSpiderWires(boat.pirate, boon, spider);
+				boat.pirate.lock();
+			}
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	public <T extends BãßBȍőnʸᴰ<T>> void 𝔦𝔫𝔦𝔱𝔅𝔬𝔫𝔢𝔐𝔞𝔤𝔦𝔠(BãßBȍőnʸᴰ<T> boon, BãßBȍőnSpider spider, Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> duytschenCoffins) {
+		try {
+			//System.out.println("INIT "+boon.getClass().getName());
+			
+			for (Class<?> duytschenType:duytschenCoffins.keySet()) {
+				BãßBȍőnCoffinDuytschenᵗˣᵗ duytschenCoffin = duytschenCoffins.get(duytschenType);
+				//System.out.println("INIT.REG_TXT "+duytschenType+" senseResult="+duytschenCoffin);
+				spider.registrateEgg(duytschenType, new BãßBȍőnSpiderSilk() {
+					@Override
+					public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
+							throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+						return duytschenCoffin;
+					}
+				});
+			}
+			for (Annotation anno:boon.getClass().getDeclaredAnnotations()) {
+				//System.out.println("INIT.REG_ANNO "+anno.annotationType());
+				spider.registrateEgg(anno.annotationType(), new BãßBȍőnSpiderSilk() {
+					@Override
+					public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
+							throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+						return anno;
+					}
+				});
+			}
+			
+			
+			Set<Class<?>> ydmods = new HashSet<>();
+			for (PiratePhaseBoat boat : loadPirateBoats(boon)) {
+				//System.out.println("INIT.RUN "+boat.pirateClazz.getName());
+				
+				if (ydmods.add(boat.pirateClazz.getDeclaringClass())) {
+					//System.out.println("INIT.REG_MOD "+boat.pirateClazz.getDeclaringClass());
+					spider.registrateEgg(boat.pirateClazz.getDeclaringClass(), new BãßBȍőnSpiderSilk() {
+						@Override
+						public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
+								throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+							return boonTmp;
+						}
+					});
+				}
+				registrateSpiderEggs(boat.pirateClazz, spider, boat.pirate);
+				initSpiderWires(boat.pirate, boon, spider);
+				BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ soundOf = boat.pirate.init();
+				Class<?> soundOfType = soundOf.getClass().getInterfaces()[0]; // TOOD ....
+				if (ydmods.add(soundOfType)) {
+					//System.out.println("INIT.REG_SND "+soundOfType);
+					spider.registrateEgg(soundOfType, new BãßBȍőnSpiderSilk() {
+						@Override
+						public Object senseWire(BãßBȍőnʸᴰ<?> boonTmp, String name, String description)
+								throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+							return soundOf;
+						}
+					});
+				}
+			}
+			initSpiderWires(boon, boon, spider);
+		} catch (Exception e) {
+			throw new RuntimeException(e);
+		}
+	}
+	
+	private static void initSpiderWires(Object target, BãßBȍőnʸᴰ<?> boon, BãßBȍőnSpider spider) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		//System.out.println("SCAN-BOON-FIELD: "+boon.getClass().getSimpleName());
+		for (Field m:target.getClass().getDeclaredFields()) {
+			if (!m.isAnnotationPresent(BãßBȍőnSpiderWire注.class)) {
+				continue;
+			}
+			BãßBȍőnSpiderWire注 anno = m.getAnnotation(BãßBȍőnSpiderWire注.class);
+			BãßBȍőnSpiderSilk silkRoad = spider.silkRoad(m.getType());
+			Object bean = silkRoad.senseWire(boon, anno.name(), anno.description());
+			//System.out.println("type: "+ m.getType() +" wth name: "+anno.name()+" of boon: "+boon+" result: "+bean.getClass().getName());
+			
+			m.setAccessible(true);
+			m.set(target, bean);
+		}
+	}
+	
+	private static <T extends BãßBȍőnʸᴰ<T>> void registrateSpiderEggs(Class<?> scanClass, BãßBȍőnSpider spider, BãßBȍőnꝐŕḯṿª₮ḕ pirate) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+		for (Method m:scanClass.getDeclaredMethods()) {
+			if (!m.isAnnotationPresent(BãßBȍőnSpiderEgg注.class)) {
+				continue;
+			}
+			//System.out.println("annoEgg: "+boon.getClass().getSimpleName()+"."+boon+" from: "+declaredClass.getName()+" m="+m.toGenericString());
+			spider.registrateEgg(m.getReturnType(), pirate, m);
+		}
+	}
+	
+	private static class PiratePhaseBoat {
+		private Class<BãßBȍőnꝐŕḯṿª₮ḕ> pirateClazz;
+		private BãßBȍőnꝐŕḯṿª₮ḕ pirate;
+		
+		private PiratePhaseBoat(Class<BãßBȍőnꝐŕḯṿª₮ḕ> pirateClazz) {
+			if (pirateClazz.isEnum()) {
+				throw new IllegalStateException("Can't hide enum pirate type: "+pirateClazz);
+			}
+			this.pirateClazz = pirateClazz;
+			try {
+				this.pirate = (BãßBȍőnꝐŕḯṿª₮ḕ) pirateClazz.getConstructor().newInstance();
+			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
+					| NoSuchMethodException | SecurityException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+	
+	private static <T extends BãßBȍőnʸᴰ<T>> List<PiratePhaseBoat> loadPirateBoats(BãßBȍőnʸᴰ<T> boon) {
+		List<PiratePhaseBoat> boonInits = new ArrayList<>();
+		List<PiratePhaseBoat> serviceInits = new ArrayList<>();
+		walkPrivate(boon, v -> {
+			//System.out.println("INIT.SCAN "+v.getName());
+			BãßBȍőnPiratePhaseBarrier注 anno = v.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
+			if (anno != null) {
+				boonInits.add(new PiratePhaseBoat(v));
+			} else {
+				serviceInits.add(new PiratePhaseBoat(v));
+			}
+		});
+		
+		boonInits.sort(new Comparator<PiratePhaseBoat>() {
+			@Override
+			public int compare(PiratePhaseBoat p0, PiratePhaseBoat p1) {
+				BãßBȍőnPiratePhaseBarrier注 anno0 = p0.pirateClazz.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
+				BãßBȍőnPiratePhaseBarrier注 anno1 = p1.pirateClazz.getAnnotation(BãßBȍőnPiratePhaseBarrier注.class);
+				return Integer.compare(anno0.order(), anno1.order());
+			}
+		});
+		
+		List<PiratePhaseBoat> result = new ArrayList<>();
+		for (PiratePhaseBoat startupPhase:boonInits) {
+			result.add(startupPhase);
+			for (PiratePhaseBoat v:new ArrayList<>(serviceInits)) {
+				int depCount = 0;
+				List<Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ>> deps = new ArrayList<>();
+				BãßBȍőnPiratePhase注 anno = v.pirateClazz.getAnnotation(BãßBȍőnPiratePhase注.class);
+				if (anno != null) {
+					deps.addAll(Arrays.asList(anno.dependencies()));
+				} else {
+					deps.add(BãßBȍőnPirateʸᴰ.שְׁלֹמֹה.DEFAULT_PHASE);
+				}
+				for (Class<?> clazz:deps) {
+					for (PiratePhaseBoat doneInit:result) {
+						if (clazz.equals(doneInit.pirateClazz)) {
+							depCount++;
+						}
+					}
+				}
+				if (depCount == deps.size()) {
+					result.add(v);
+					serviceInits.remove(v);
+				}
+			}
+		}
+		result.addAll(serviceInits);
+		return result;
+	}
+	
+	@SuppressWarnings("unchecked")
+	private static <T extends BãßBȍőnʸᴰ<T>> void walkPrivate(BãßBȍőnʸᴰ<T> boon, Consumer<Class<BãßBȍőnꝐŕḯṿª₮ḕ>> runPrivate) {
+		for (Class<?> interfaceClass:walkInterfaces(boon.getClass(), new LinkedHashSet<>())) {
+			for (Class<?> declaredClass:interfaceClass.getDeclaredClasses()) {
+				if (!BãßBȍőnꝐŕḯṿª₮ḕ.class.isAssignableFrom(declaredClass)) {
+					continue;
+				}
+				runPrivate.accept((Class<BãßBȍőnꝐŕḯṿª₮ḕ>)declaredClass);
+			}
+		}
+		for (Class<?> declaredClass:boon.getClass().getDeclaredClasses()) {
+			if (!BãßBȍőnꝐŕḯṿª₮ḕ.class.isAssignableFrom(declaredClass)) {
+				continue;
+			}
+			runPrivate.accept((Class<BãßBȍőnꝐŕḯṿª₮ḕ>)declaredClass);
+		}
+	}
+	
+	public static Optional<Class<?>> findInterfaceByAnnotation(Class<?> clazz, Class<? extends Annotation> annoType) {
+		return walkInterfaces(clazz, new LinkedHashSet<>()).stream().filter(v -> v.isAnnotationPresent(annoType)).findFirst();
+	}
+	
+	public static Set<Class<?>> walkInterfaces(Class<?> clazz, Set<Class<?>> result) {
+		return walkTree(clazz, result, v -> Arrays.asList(v.getInterfaces()), v -> v.getSuperclass());
+	}
+	
+	public static <N> Set<N> walkTree(N node, Set<N> result, Function<N, Collection<N>> childs, Function<N,N> resolve) {
+		while (node != null) {
+			for (N next : childs.apply(node)) {
+				if (result.add(next)) {
+					walkTree(next, result, childs, resolve);
+				}
+			}
+			node = resolve.apply(node);
+		}
+		return result;
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffin.java

@@ -0,0 +1,15 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnCoffin {
+	
+	BãßBȍőnCoffinGhost UNHOLY(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName);
+	
+	BãßBȍőnCoffinGhostSpell UNHOLY_SPELL(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName);
+	
+	<T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T NOISE_OF(Class<T> noiseName);
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffinDuytschenᵗˣᵗ.java

@@ -0,0 +1,80 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
+
+import java.util.Map;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnCoffinDuytschenᵗˣᵗ {
+	
+	static void ײₚᵤₜI18Nᵗˣᵗײ(Map<Class<? extends BãßBȍőnCoffinDuytschenᵗˣᵗ>,BãßBȍőnCoffinDuytschenᵗˣᵗ> map, BãßBȍőnCoffin wrap) {
+		BASIC tank1 = new BASIC();
+		tank1.init(wrap);
+		map.put(BASIC.class, tank1);
+		
+		ױןיװיזױױודזיןןזזזןױ tank2 = new ױןיװיזױױודזיןןזזזןױ();
+		tank2.init(wrap);
+		map.put(ױןיװיזױױודזיןןזזזןױ.class, tank2);
+		
+		中國 tank3 = new 中國();
+		tank3.init(wrap);
+		map.put(中國.class, tank3);
+		
+		𓃬𓍄𓋹𓀭 tank4 = new 𓃬𓍄𓋹𓀭();
+		tank4.init(wrap);
+		map.put(𓃬𓍄𓋹𓀭.class, tank4);
+		
+		عربى tank5 = new عربى();
+		tank5.init(wrap);
+		map.put(عربى.class, tank5);
+		
+		עִברִית tank6 = new עִברִית();
+		tank6.init(wrap);
+		map.put(עִברִית.class, tank6);
+	}
+	
+	class BãßBȍőnCoffinDuytschenᴬᵖᶦ implements BãßBȍőnCoffinDuytschenᵗˣᵗ {
+		BãßBȍőnCoffin ᵃpᵢ;
+		void init(BãßBȍőnCoffin wrap) {
+			this.ᵃpᵢ = wrap;
+		}
+	}
+	
+	class ױןיװיזױױודזיןןזזזןױ extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
+		public BãßBȍőnCoffinGhost ײןןזזײ(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> ײןןךז) { return ᵃpᵢ.UNHOLY(ײןןךז); }
+		public BãßBȍőnCoffinGhostSpell ײזזןןײןןךזזײ(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> ײןןךז) { return ᵃpᵢ.UNHOLY_SPELL(ײןןךז); }
+		public <T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T ײןזןזןזײ(Class<T> ןזײ) { return ᵃpᵢ.NOISE_OF(ןזײ); }
+	}
+	
+	class BASIC extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
+		public BãßBȍőnCoffinGhost UNHOLY(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName) { return ᵃpᵢ.UNHOLY(familyName); }
+		public BãßBȍőnCoffinGhostSpell UNHOLY_SPELL(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> familyName) { return ᵃpᵢ.UNHOLY_SPELL(familyName); }
+		public <T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T NOISE_OF(Class<T> noiseName) { return ᵃpᵢ.NOISE_OF(noiseName); }
+	}
+	
+	class 中國 extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
+		public BãßBȍőnCoffinGhost 邪惡的(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> 姓) { return ᵃpᵢ.UNHOLY(姓); }
+		public BãßBȍőnCoffinGhostSpell 邪惡的龸魅力(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> 姓) { return ᵃpᵢ.UNHOLY_SPELL(姓); }
+		public <T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T 噪音龸的(Class<T> 音名) { return ᵃpᵢ.NOISE_OF(音名); }
+	}
+	
+	class 𓃬𓍄𓋹𓀭 extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
+		public BãßBȍőnCoffinGhost 𓆙𓄿𓏀𓃟𓇋𓇋𓄋(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> 𓊲𓅃𓅓𓇋𓊝) { return ᵃpᵢ.UNHOLY(𓊲𓅃𓅓𓇋𓊝); }
+		public BãßBȍőnCoffinGhostSpell 𓆙𓄿𓏀𓃟𓇋𓇋𓄋𓐘𓆘𓉯𓌇𓆅𓆅(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> 𓊲𓅃𓅓𓇋𓊝) { return ᵃpᵢ.UNHOLY_SPELL(𓊲𓅃𓅓𓇋𓊝); }
+		public <T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T 𓁵𓇋𓌗𓁬𓐘𓅂𓁿𓆑(Class<T> 𓈖𓇋𓌗𓌇𓈖𓅂𓅓) { return ᵃpᵢ.NOISE_OF(𓈖𓇋𓌗𓌇𓈖𓅂𓅓); }
+	}
+	
+	class عربى extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
+		public BãßBȍőnCoffinGhost غير۵مقدس(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> لقب) { return ᵃpᵢ.UNHOLY(لقب); }
+		public BãßBȍőnCoffinGhostSpell غير۵مقدس۵سحر(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> لقب) { return ᵃpᵢ.UNHOLY_SPELL(لقب); }
+		public <T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T ضوضاء۵من(Class<T> هناك۵صوت) { return ᵃpᵢ.NOISE_OF(هناك۵صوت); }
+	}
+	
+	class עִברִית extends BãßBȍőnCoffinDuytschenᴬᵖᶦ {
+		public BãßBȍőnCoffinGhost לאײקדוש(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> שםײמשפחה) { return ᵃpᵢ.UNHOLY(שםײמשפחה); }
+		public BãßBȍőnCoffinGhostSpell לאײקדושײקֶסֶם(Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> שםײמשפחה) { return ᵃpᵢ.UNHOLY_SPELL(שםײמשפחה); }
+		public <T extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ> T צלילײשל(Class<T> ישײצליל) { return ᵃpᵢ.NOISE_OF(ישײצליל); }
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffinGhost.java

@@ -0,0 +1,97 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
+
+import java.util.List;
+import java.util.Map;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnCoffinGhost {
+	
+	Object GHOST_OBJ(StringGhostKey key);
+
+	@SuppressWarnings("unchecked")
+	default <Y> Y GHOST_OBJ(StringGhostKey key, Class<Y> type) {
+		return (Y) GHOST_OBJ(key);
+	}
+	
+	default StringUnicode GHOST_UNICODE(StringGhostKey key) {
+		return StringUnicode.class.cast(GHOST_OBJ(key));
+	}
+	
+	default String GHOST_STR(StringGhostKey key) {
+		return String.class.cast(GHOST_OBJ(key));
+	}
+
+	default Short GHOST_SHORT(StringGhostKey key) {
+		return Short.class.cast(GHOST_OBJ(key));
+	}
+	
+	default Character GHOST_CHAR(StringGhostKey key) {
+		return Character.class.cast(GHOST_OBJ(key));
+	}
+	
+	default Integer GHOST_INT(StringGhostKey key) {
+		return Integer.class.cast(GHOST_OBJ(key));
+	}
+	
+	default Long GHOST_LONG(StringGhostKey key) {
+		return Long.class.cast(GHOST_OBJ(key));
+	}
+	
+	default Boolean GHOST_BOOL(StringGhostKey key) {
+		return Boolean.class.cast(GHOST_OBJ(key));
+	}
+	
+	default Float GHOST_FLOAT(StringGhostKey key) {
+		return Float.class.cast(GHOST_OBJ(key));
+	}
+	
+	default Double GHOST_DOUBLE(StringGhostKey key) {
+		return Double.class.cast(GHOST_OBJ(key));
+	}
+
+	@SuppressWarnings("unchecked")
+	default Map<String,Object> GHOST_MAP_OBJ(StringGhostKey key) {
+		return Map.class.cast(GHOST_OBJ(key));
+	}
+	
+	default Object GHOST_MAP_OBJ_VALUE(StringGhostKey key, String mapKey) {
+		return GHOST_MAP_OBJ(key).get(mapKey);
+	}
+	
+	@SuppressWarnings("unchecked")
+	default Map<String,String> GHOST_MAP_STR(StringGhostKey key) {
+		return Map.class.cast(GHOST_OBJ(key));
+	}
+	
+	default String GHOST_MAP_STR_VALUE(StringGhostKey key, String mapKey) {
+		return GHOST_MAP_STR(key).get(mapKey);
+	}
+	
+	@SuppressWarnings("unchecked")
+	default Map<String,Integer> GHOST_MAP_INT(StringGhostKey key) {
+		return Map.class.cast(GHOST_OBJ(key));
+	}
+	
+	default Integer GHOST_MAP_INT_VALUE(StringGhostKey key, String mapKey) {
+		return GHOST_MAP_INT(key).get(mapKey);
+	}
+	
+	@SuppressWarnings("unchecked")
+	default List<Object> GHOST_LIST_OBJ(StringGhostKey key) {
+		return List.class.cast(GHOST_OBJ(key));
+	}
+	
+	@SuppressWarnings("unchecked")
+	default List<String> GHOST_LIST_STR(StringGhostKey key) {
+		return List.class.cast(GHOST_OBJ(key));
+	}
+	
+	@SuppressWarnings("unchecked")
+	default List<Integer> GHOST_LIST_INT(StringGhostKey key) {
+		return List.class.cast(GHOST_OBJ(key));
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffinGhostSpell.java

@@ -0,0 +1,25 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnCoffinGhostSpell extends BãßBȍőnCoffinGhost {
+	
+	Object PUT_GHOST(StringGhostKey key, Object value);
+	
+	default void PUT_GHOST_MAP(StringGhostKey key) {
+		PUT_GHOST(key, new HashMap<>());
+	}
+	
+	default void PUT_GHOST_LIST(StringGhostKey key) {
+		PUT_GHOST(key, new ArrayList<>());
+	}
+	
+	static BãßBȍőnCoffinGhostSpell castᴼᶠ(BãßBȍőnCoffinGhost death) {
+		return (BãßBȍőnCoffinGhostSpell) death;
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/BãßBȍőnCoffinGhostSpellLock.java

@@ -0,0 +1,59 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.function.Function;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnCoffinGhostSpellLock extends BãßBȍőnCoffinGhostSpell {
+	
+	BãßBȍőnCoffinGhost LOCK();
+	
+	static BãßBȍőnCoffinGhostSpellLock castᴼᶠ(BãßBȍőnCoffinGhost death) {
+		return (BãßBȍőnCoffinGhostSpellLock) death;
+	}
+	
+	static BãßBȍőnCoffinGhostSpellLock instanceᴺᵉʷ() {
+		Function<Map<StringGhostKey,Object>,BãßBȍőnCoffinGhost> keyMaker = v -> {
+			Map<StringGhostKey,Object> summonedGhosts = new HashMap<>(v);
+			for (StringGhostKey entity:v.keySet()) {
+				Object spirit = summonedGhosts.get(entity);
+				if (spirit instanceof List) {
+					summonedGhosts.put(entity, Collections.unmodifiableList((List<?>) spirit));
+				}
+				if (spirit instanceof Map) {
+					summonedGhosts.put(entity, Collections.unmodifiableMap((Map<?,?>) spirit));
+				}
+			}
+			return new BãßBȍőnCoffinGhost() {
+				@Override
+				public Object GHOST_OBJ(StringGhostKey key) {
+					return summonedGhosts.get(key);
+				}
+			};
+		};
+		return new BãßBȍőnCoffinGhostSpellLock() {
+			private final Map<StringGhostKey,Object> ouijaBoard = new HashMap<>();
+			
+			@Override
+			public BãßBȍőnCoffinGhost LOCK() {
+				return keyMaker.apply(ouijaBoard);
+			}
+			
+			@Override
+			public Object GHOST_OBJ(StringGhostKey key) {
+				return ouijaBoard.get(key);
+			}
+			
+			@Override
+			public Object PUT_GHOST(StringGhostKey key, Object value) {
+				return ouijaBoard.put(key, value);
+			}
+		};
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpider.java

@@ -0,0 +1,85 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public class BãßBȍőnSpider {
+	
+	private final Map<Class<?>, BãßBȍőnSpiderSilk> spiderWeb = new HashMap<>();
+	private final List<BãßBȍőnSpiderSperm> spiderSperm;
+	
+	public BãßBȍőnSpider(List<BãßBȍőnSpiderSperm> spiderSperm) {
+		this.spiderSperm = spiderSperm;
+	}
+	
+	public boolean hasEggType(Class<?> eggType) {
+		return spiderWeb.containsKey(eggType);
+	}
+	
+	public BãßBȍőnSpiderSilk silkRoad(Class<?> eggType) {
+		BãßBȍőnSpiderSilk silkRoad = spiderWeb.get(eggType);
+		if (silkRoad == null) {
+			throw new IllegalStateException("No silk road found for type: "+eggType);
+		}
+		return silkRoad;
+	}
+	
+	public void registrateEgg(Class<?> eggType, BãßBȍőnSpiderSilk spiderSilk) {
+		if (spiderWeb.containsKey(eggType)) {
+			throw new IllegalStateException("Can't registate class twice: "+eggType);
+		}
+		spiderWeb.put(eggType, spiderSilk);
+	}
+	
+	public void registrateEgg(Class<?> eggType, BãßBȍőnꝐŕḯṿª₮ḕ pirate, Method m) {
+		registrateEgg(eggType, createSenseWire(pirate, m));
+	}
+	
+	public BãßBȍőnSpiderSilk createSenseWire(BãßBȍőnꝐŕḯṿª₮ḕ pirate, Method m) {
+		boolean valid = false;
+		Class<?>[] para = m.getParameterTypes();
+		if (para.length == 0) {
+			valid = true;
+		}
+		if (para.length == 1 && BãßBȍőnʸᴰ.class.isAssignableFrom(para[0])) {
+			valid = true;
+		}
+		if (para.length == 2 && BãßBȍőnʸᴰ.class.isAssignableFrom(para[0]) && String.class.isAssignableFrom(para[1])) {
+			valid = true;
+		}
+		if (para.length == 3 && BãßBȍőnʸᴰ.class.isAssignableFrom(para[0]) && String.class.isAssignableFrom(para[1]) && String.class.isAssignableFrom(para[2])) {
+			valid = true;
+		}
+		if (!valid) {
+			throw new IllegalStateException("Unknown method parameters on: "+m.getDeclaringClass().getSimpleName()+"."+m.toGenericString());
+		}
+		return new BãßBȍőnSpiderSilk() {
+			
+			@Override
+			public Object senseWire(BãßBȍőnʸᴰ<?> boon, String name, String description) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
+				Class<?>[] para = m.getParameterTypes();
+				if (para.length == 0) {
+					return m.invoke(pirate);
+				}
+				if (para.length == 1 && BãßBȍőnʸᴰ.class.isAssignableFrom(para[0])) {
+					return m.invoke(pirate, boon);
+				}
+				if (para.length == 2 && BãßBȍőnʸᴰ.class.isAssignableFrom(para[0]) && String.class.isAssignableFrom(para[1])) {
+					return m.invoke(pirate, boon, name);
+				}
+				if (para.length == 3 && BãßBȍőnʸᴰ.class.isAssignableFrom(para[0]) && String.class.isAssignableFrom(para[1]) && String.class.isAssignableFrom(para[2])) {
+					return m.invoke(pirate, boon, name, description);
+				}
+				throw new IllegalStateException("Unknown method parameters on: "+m.getDeclaringClass().getSimpleName()+"."+m.toGenericString());
+			}
+		};
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderEgg注.java

@@ -0,0 +1,15 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface BãßBȍőnSpiderEgg注 {
+
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderSilk.java

@@ -0,0 +1,12 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
+
+import java.lang.reflect.InvocationTargetException;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnSpiderSilk {
+	
+	Object senseWire(BãßBȍőnʸᴰ<?> boon, String name, String description) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException;
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderSperm.java

@@ -0,0 +1,9 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnSpiderSperm {
+	
+	Object locateBean(Class<?> beanType);
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒄᓫᣔᐪᑋ/ᔆᣖᑊᒄᓫᣗ/BãßBȍőnSpiderWire注.java

@@ -0,0 +1,18 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD})
+public @interface BãßBȍőnSpiderWire注 {
+
+	String name() default "";
+	
+	String description() default "";
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnAnnotationʸᴰ.java

@@ -0,0 +1,40 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import java.lang.annotation.Annotation;
+import java.util.LinkedHashSet;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.DefaultBȍőnLoader;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnAnnotationʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
+	
+	@BãßBȍőnPiratePhase注(dependencies = {BãßBȍőnPirateʸᴰ.βrahmanBoonLaw.class})
+	public static final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnAnnotationʸᴰ<?> boon;
+		
+		@Override
+		public BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ.Void init() {
+			for (Class<?> interfaceClass:DefaultBȍőnLoader.walkInterfaces(boon.getClass(), new LinkedHashSet<>())) {
+				BãßBȍőnAnnotation注 anno = interfaceClass.getAnnotation(BãßBȍőnAnnotation注.class);
+				if (anno == null) {
+					continue;
+				}
+				for (Class<? extends Annotation> required:anno.required()) {
+					if (!boon.getClass().isAnnotationPresent(required)) {
+						throw new IllegalStateException("Missing required annotation: "+required.getSimpleName()+" on: "+boon.getClass().getSimpleName());
+					}
+				}
+			}
+			return BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ.Void.實施;
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnAnnotation注.java

@@ -0,0 +1,19 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import java.lang.annotation.Annotation;
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BãßBȍőnAnnotation注 {
+
+	Class<? extends Annotation>[] required() default {};
+	
+	Class<? extends Annotation>[] optional() default {};
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnAuthorʸᴰ.java

@@ -0,0 +1,47 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnAnnotation注(optional = {DuytsDocAuthor注.class})
+public interface BãßBȍőnAuthorʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
+	
+	@BãßBȍőnPiratePhase注(dependencies = {BãßBȍőnPirateʸᴰ.βrahmanBoonLaw.class})
+	public static final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+		private static final StringGhostKey GHOST_NAME = StringGhostKey.asciiᴳʰᵒˢᵗ();
+		private static final StringGhostKey GHOST_COPYRIGHT = StringGhostKey.asciiᴳʰᵒˢᵗ();
+		private static final StringUnicode DEFAULT_NAME = StringUnicode.valueOf("奴隸來自　仙上主天");
+		private static final StringUnicode DEFAULT_COPYRIGHT = StringUnicode.valueOf("©Δ∞ 仙上主天");
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnAuthorʸᴰ<?> boon;
+
+//		@BãßBȍőnSpiderWire注
+//		private BãßBȍőnAuthor注 anno;
+		
+		@Override
+		public BãßBȍőnAuthor響ᴼᶠ init() {
+			DuytsDocAuthor注 anno = boon.getClass().getAnnotation(DuytsDocAuthor注.class);
+			boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_NAME, anno!=null?StringUnicode.valueOf(anno.name()):DEFAULT_NAME);
+			boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_COPYRIGHT, anno!=null?StringUnicode.valueOf(anno.copyright()):DEFAULT_COPYRIGHT);
+			return new BãßBȍőnAuthor響ᴼᶠ() {
+				@Override
+				public StringUnicode naam() {
+					return boon.toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_NAME);
+				}
+				
+				@Override
+				public StringUnicode kopieërRecht() {
+					return boon.toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_COPYRIGHT);
+				}
+			};
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnAuthor響ᴼᶠ.java

@@ -0,0 +1,45 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnDuytsFlüstern注(purpose = "Noise of author annotation fields.")
+@BãßBȍőnDuytschen注(中國 = "低音　骨　作者　噪音　的", BASIC = "BASS_BONE_AUTHOR_NOISE_OF", 𓃬𓍄𓋹𓀭 = "𓃀𓅂𓋴　𓂿𓌇　𓅃𓅱𓋊𓌟𓁹　𓈖𓇋𓌗𓌇　𓅂𓏲𓆑")
+public interface BãßBȍőnAuthor響ᴼᶠ extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ {
+	
+	@BãßBȍőnDuytschen注(中國 = "姓名", BASIC = "NAME", 𓃬𓍄𓋹𓀭 = "𓈖𓅂𓅓")
+	StringUnicode naam();
+	
+	@BãßBȍőnDuytschen注(中國 = "版權", BASIC = "COPYRIGHT", 𓃬𓍄𓋹𓀭 = "𓎡𓊝𓇋𓇋𓂏𓇋𓇋𓈏")
+	StringUnicode kopieërRecht();
+	
+	/*
+	@BãßBȍőnDuytsFlüstern注(purpose = "低音　骨　作者　噪音　的")
+	class 中國 extends BãßBȍőnAuthor響ᴬᵖᶦ {
+		public StringUnicode 姓名() { return ᵃpᵢ.naam(); }
+		public StringUnicode 版權() { return ᵃpᵢ.kopieërRecht(); }
+		
+		public BãßBȍőnAuthor響ᴬᵖᶦ test() {
+			BãßBȍőnAuthor響ᴼᶠ res = null;
+			
+			ᵃpᵢ.test().toApi(null);
+			
+			return res.toApi(getClass());
+		}
+	}
+	
+	@BãßBȍőnDuytsFlüstern注(purpose = "BASS_BONE_AUTHOR_NOISE_OF")
+	class BASIC extends BãßBȍőnAuthor響ᴬᵖᶦ {
+		public StringUnicode NAME() { return ᵃpᵢ.naam(); }
+		public StringUnicode COPYRIGHT() { return ᵃpᵢ.kopieërRecht(); }
+	}
+	
+	@BãßBȍőnDuytsFlüstern注(purpose = "𓃀𓅂𓋴　𓂿𓌇　𓅃𓅱𓋊𓌟𓁹　𓈖𓇋𓌗𓌇　𓅂𓏲𓆑")
+	class 𓃬𓍄𓋹𓀭 extends BãßBȍőnAuthor響ᴬᵖᶦ {
+		public StringUnicode 𓈖𓅂𓅓() { return ᵃpᵢ.naam(); }
+		public StringUnicode 𓎡𓊝𓇋𓇋𓂏𓇋𓇋𓈏() { return ᵃpᵢ.kopieërRecht(); }
+	}
+	*/
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnDuytsFlüsternʸᴰ.java

@@ -0,0 +1,40 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnAnnotation注(optional = {BãßBȍőnDuytsFlüstern注.class})
+public interface BãßBȍőnDuytsFlüsternʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
+	
+	@BãßBȍőnPiratePhase注(dependencies = {BãßBȍőnPirateʸᴰ.βrahmanBoonLaw.class})
+	final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+		private static final StringGhostKey GHOST_PURPOSE = StringGhostKey.asciiᴳʰᵒˢᵗ();
+		private static final StringUnicode DEFAULT_PURPOSE = StringUnicode.valueOf("Undefined");
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnDuytsFlüsternʸᴰ<?> boon;
+		
+		@Override
+		public BãßBȍőnDuytsFlüstern響ᴼᶠ init() {
+			BãßBȍőnDuytsFlüstern注 anno = boon.getClass().getAnnotation(BãßBȍőnDuytsFlüstern注.class);
+			StringUnicode beanPurpose = DEFAULT_PURPOSE;
+			if (anno != null && !anno.purpose().isBlank()) {
+				beanPurpose = StringUnicode.valueOf(anno.purpose());
+			}
+			boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_PURPOSE, beanPurpose);
+			return new BãßBȍőnDuytsFlüstern響ᴼᶠ() {
+				@Override
+				public StringUnicode doel() {
+					return boon.toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_PURPOSE);
+				}
+			};
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnDuytsFlüstern注.java

@@ -0,0 +1,16 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BãßBȍőnDuytsFlüstern注 {
+	
+	String purpose();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnDuytsFlüstern響ᴼᶠ.java

@@ -0,0 +1,14 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnDuytsFlüstern注(purpose = "Noise of clazz annotation fields.")
+@BãßBȍőnDuytschen注(中國 = "低音　骨　杜伊岑　耳語　的", BASIC = "BASS_BONE_DUYTS_WHISPER_OF", 𓃬𓍄𓋹𓀭 = "𓃀𓅂𓋴　𓂿𓌇　𓀍𓅱𓋏𓌏𓆘　𓄍𓌟𓇋𓌗𓉱𓌇𓁹　𓅂𓏲𓆑")
+public interface BãßBȍőnDuytsFlüstern響ᴼᶠ extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ {
+	
+	@BãßBȍőnDuytschen注(中國 = "目的", BASIC = "PURPOSE", 𓃬𓍄𓋹𓀭 = "𓉯𓅱𓁹𓎥𓋴𓆑")
+	StringUnicode doel();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnDuytschen注.java

@@ -0,0 +1,21 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD, ElementType.TYPE})
+public @interface BãßBȍőnDuytschen注 {
+	
+	String 中國();
+	
+	String BASIC() default Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.STR_EMPTY;
+	
+	String 𓃬𓍄𓋹𓀭() default Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.STR_EMPTY;
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnExportʸᴰ.java

@@ -0,0 +1,67 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPiratePhase注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnPirateʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.BãßBȍőnCoffinDuytschenᵗˣᵗ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnAnnotation注(optional = {BãßBȍőnExport注.class})
+public interface BãßBȍőnExportʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
+	
+	@BãßBȍőnPiratePhase注(dependencies = {BãßBȍőnPirateʸᴰ.βrahmanBoonLaw.class})
+	final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+		private static final StringGhostKey GHOST_ARTIFACT = StringGhostKey.asciiᴳʰᵒˢᵗ();
+		private static final StringGhostKey GHOST_GROUP = StringGhostKey.asciiᴳʰᵒˢᵗ();
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnExportʸᴰ<?> boon;
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnAuthor響ᴼᶠ frw;
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnCoffinDuytschenᵗˣᵗ.𓃬𓍄𓋹𓀭 𓁀;
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnCoffinDuytschenᵗˣᵗ.中國 棺材;
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnCoffinDuytschenᵗˣᵗ.عربى فاصوليا;
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnCoffinDuytschenᵗˣᵗ.ױןיװיזױױודזיןןזזזןױ ױײןזזזןײ;
+		
+		@Override
+		public BãßBȍőnExport響ᴼᶠ init() {
+			BãßBȍőnExport注 anno = boon.getClass().getAnnotation(BãßBȍőnExport注.class);
+			String exportArtifact = boon.getClass().getSimpleName();
+			String exportGroup = boon.getClass().getPackage().getName();
+			if (anno != null && !anno.artifact().isBlank()) {
+				exportArtifact = anno.artifact();
+			}
+			if (anno != null && !anno.group().isBlank()) {
+				exportGroup = anno.group();
+			}
+			
+			𓁀.𓆙𓄿𓏀𓃟𓇋𓇋𓄋𓐘𓆘𓉯𓌇𓆅𓆅(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_ARTIFACT, StringUnicode.valueOf(exportArtifact));
+			فاصوليا.غير۵مقدس۵سحر(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_GROUP, StringUnicode.valueOf(exportGroup));
+			return new BãßBȍőnExport響ᴼᶠ() {
+				@Override
+				public StringUnicode artifact() {
+					return ױײןזזזןײ.ײןןזזײ(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_ARTIFACT);
+				}
+				
+				@Override
+				public StringUnicode groep() {
+					return 棺材.邪惡的(Ꝑŕḯṿª₮ḕ.class).GHOST_UNICODE(GHOST_GROUP);
+				}
+			};
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnExport注.java

@@ -0,0 +1,19 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BãßBȍőnExport注 {
+	
+	String artifact() default Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.STR_EMPTY;
+	
+	String group();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/BãßBȍőnExport響ᴼᶠ.java

@@ -0,0 +1,17 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnDuytsFlüstern注(purpose = "Noise of export annotation fields.")
+@BãßBȍőnDuytschen注(中國 = "低音　骨　出口　噪音　的", BASIC = "BASS_BONE_EXPORT_NOISE_OF", 𓃬𓍄𓋹𓀭 = "𓃀𓅂𓋴　𓂿𓌇　𓎡𓋴𓊨𓊖𓁹𓈏　𓈖𓇋𓌗𓌇　𓅂𓏲𓆑")
+public interface BãßBȍőnExport響ᴼᶠ extends BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ {
+	
+	@BãßBȍőnDuytschen注(中國 = "人工製品", BASIC = "ARTIFACT", 𓃬𓍄𓋹𓀭 = "𓅂𓁀𓀳𓊲𓋌")
+	StringUnicode artifact();
+	
+	@BãßBȍőnDuytschen注(中國 = "團體", BASIC = "GROUP", 𓃬𓍄𓋹𓀭 = "𓎸𓎥𓅱𓊰")
+	StringUnicode groep();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnPiratePhaseBarrier注.java

@@ -0,0 +1,16 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BãßBȍőnPiratePhaseBarrier注 {
+	
+	int order();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnPiratePhase注.java

@@ -0,0 +1,16 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BãßBȍőnPiratePhase注 {
+	
+	Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ>[] dependencies();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnPirateʸᴰ.java

@@ -0,0 +1,111 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.BãßBȍőnʸᴰ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytsFlüstern注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytschen注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+/**
+ * Bass bone pirate phase barriers.
+ */
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnDuytsFlüstern注(purpose = "Adds extensible phase barriers for pirates.")
+@BãßBȍőnDuytschen注(中國 = "低音　骨　海盜", BASIC = "BASS_BONE_PIRATE", 𓃬𓍄𓋹𓀭 = "𓃀𓅂𓋴　𓂿𓌇　𓉯𓋴𓅂𓇋𓇋𓌇")
+public interface BãßBȍőnPirateʸᴰ<T extends BãßBȍőnʸᴰ<T>> extends BãßBȍőnʸᴰ<T> {
+	
+	/**
+	 * Private member class for constants.
+	 */
+	@BãßBȍőnDuytschen注(中國 = "所羅門", BASIC = "SOLOMON", 𓃬𓍄𓋹𓀭 = "𓂲𓇁𓐂")
+	public static final class שְׁלֹמֹה {
+		// default internal framework boon phases
+		protected static final int BOON_VOID = Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ZERO;
+		protected static final int BOON_BERESHIT = BOON_VOID + Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE;
+		protected static final int BOON_LAW = BOON_BERESHIT * Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_TEN;
+		protected static final int BOON_MARRIAGE = BOON_LAW + Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ONE;
+		// default external implementation boon phases
+		protected static final int LIFE_QUADRANT_仙ᵃ = 00+00+00+1+2+3+4+5+6+7+8+9;
+		protected static final int LIFE_QUADRANT_上ᵇ = 10+11+12+13+14+15+16+17+18;
+		protected static final int LIFE_QUADRANT_主ᶜ = 19+20+21+22+23+24+25+26+27;
+		protected static final int LIFE_QUADRANT_天ᵈ = 28+29+30+31+32+33+34+35+36;
+		protected static final int LIFE_יהוה = LIFE_QUADRANT_仙ᵃ + LIFE_QUADRANT_上ᵇ + LIFE_QUADRANT_主ᶜ + LIFE_QUADRANT_天ᵈ;
+		
+		public static final Class<? extends BãßBȍőnꝐŕḯṿª₮ḕ> DEFAULT_PHASE = βrahmanLifeStartup.class;
+		
+		private שְׁלֹמֹה() {
+		}
+	}
+	
+	/**
+	 * The "void" phase.
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.BOON_VOID)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　骨　空白", BASIC = "GOD_BONE_VOID", 𓃬𓍄𓋹𓀭 = "𓂀　𓂿𓌇　𓅱𓇋𓂩")
+	public static final class βrahmanBoonVoid implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+	
+	/**
+	 * The "bereshit" phase.
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.BOON_BERESHIT)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　骨　創造", BASIC = "GOD_BONE_CREATE", 𓃬𓍄𓋹𓀭 = "𓂀　𓂿𓌇　𓎡𓂏𓅂𓇋𓇋𓈏")
+	public static final class βrahmanBoonBereshit implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+	
+	/**
+	 * The "law" phase.
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.BOON_LAW)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　骨　法律", BASIC = "GOD_BONE_LAW", 𓃬𓍄𓋹𓀭 = "𓂀　𓂿𓌇　𓃠𓅂𓍰")
+	public static final class βrahmanBoonLaw implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+	
+	/**
+	 * The "bonding" phase.
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.BOON_MARRIAGE)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　骨　婚姻", BASIC = "GOD_BONE_BONDING", 𓃬𓍄𓋹𓀭 = "𓂀　𓂿𓌇　𓅓𓅱𓋊𓇋𓇋𓆗𓇚")
+	public static final class βrahmanBoonMarriage implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+	
+	/**
+	 * The "immortal" phase.
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_QUADRANT_仙ᵃ)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　向上", BASIC = "GOD_LIFE_QUAD_UP", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓅱𓉱")
+	public static final class βrahmanLifeQuadrant仙ᵃ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+	
+	/**
+	 * The "above the" phase
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_QUADRANT_上ᵇ)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　下", BASIC = "GOD_LIFE_QUAD_DOWN", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓂧𓏲𓈁")
+	public static final class βrahmanLifeQuadrant上ᵇ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+	
+	/**
+	 * The "lords of" phase.
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_QUADRANT_主ᶜ)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　僕人", BASIC = "GOD_LIFE_QUAD_SERVANT", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓀠𓀤𓀟𓀜")
+	public static final class βrahmanLifeQuadrant主ᶜ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+	
+	/**
+	 * The "heaven" phase.
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_QUADRANT_天ᵈ)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　地獄", BASIC = "GOD_LIFE_QUAD_HELL", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓄀𓂺𓆏𓆖")
+	public static final class βrahmanLifeQuadrant天ᵈ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+	
+	/**
+	 * The "startup" phase.
+	 */
+	@BãßBȍőnPiratePhaseBarrier注(order = שְׁלֹמֹה.LIFE_יהוה)
+	@BãßBȍőnDuytschen注(中國 = "仙上主天　生活　象限　啟動", BASIC = "GOD_LIFE_STARTUP", 𓃬𓍄𓋹𓀭 = "𓂀　𓃭𓇋𓆑　𓎡𓏲𓅅𓌝　𓋴𓂏𓁹𓅱𓉢")
+	public static final class βrahmanLifeStartup implements BãßBȍőnꝐŕḯṿª₮ḕ {
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnꝐŕḯṿª₮ḕ.java

@@ -0,0 +1,16 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnꝐŕḯṿª₮ḕ extends ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕḯṿª₮ḕ {
+	// note: eclipse ide does not want to refactor items with the name "Ꝑŕḯṿª₮ḕ" in it.
+	
+	default BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ init() {
+		return BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ.Void.實施;
+	}
+	
+	default void lock() {
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒃᣔᔆᔆᒃᐤᐤᣕ/ᒼᒻᣔᙆᙆ/ᣖᑊᣗᣔᐪᓫ/BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ.java

@@ -0,0 +1,11 @@
+package ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ {
+	
+	/* member */ enum Void implements BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ {
+		實施;
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/Comparableբ.java

@@ -0,0 +1,56 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Comparableբ<T> extends Comparable<T>,Babelizeբᴬᵖᶦ {
+	
+	@FunctionalInterface
+	interface זױזזױזזזז<יזזױזזז> extends Comparableբ<יזזױזזז>, BabelHinarī {
+		
+		@Override
+		default int compareTo(יזזױזזז יזזי) {
+			return יזזיױזזזױזזזזז(יזזי);
+		}
+		
+		int יזזיױזזזױזזזזז(יזזױזזז יזזי);
+	}
+	
+	@FunctionalInterface
+	interface 可比<仿製藥> extends Comparableբ<仿製藥>, BabelMandarin {
+		
+		@Override
+		default int compareTo(仿製藥 物) {
+			return 相比龸至(物);
+		}
+		
+		int 相比龸至(仿製藥 物);
+	}
+	
+	@FunctionalInterface
+	interface तुलनीय<जेनरिक> extends Comparableբ<जेनरिक>, BabelHindi {
+		
+		@Override
+		default int compareTo(जेनरिक चीज़) {
+			return तुलनाꣻप्रति(चीज़);
+		}
+		
+		int तुलनाꣻप्रति(जेनरिक चीज़);
+	}
+	
+	@FunctionalInterface
+	interface 𓌭𓍝<𓉢> extends Comparableբ<𓉢>, BabelHiero {
+		
+		@Override
+		default int compareTo(𓉢 𓐠) {
+			return 𓍝(𓐠);
+		}
+		
+		int 𓍝(𓉢 𓐠);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectScopeLimitΔ.java

@@ -0,0 +1,83 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©⍙ ∞ 仙上主天")
+public enum ObjectScopeLimitΔ { 
+	; // Empty scopes is a human thing
+	
+	enum Ꝑŕḯṿª₮ḕ {
+		;
+		
+		@Retention(RetentionPolicy.RUNTIME)
+		@Target({ElementType.TYPE})
+		@interface DeathMatchPostfix注 {
+			String match();
+			String lastBreath();
+		}
+		
+		@Retention(RetentionPolicy.RUNTIME)
+		@Target({ElementType.TYPE})
+		@interface DeathMatchPrefix注 {
+			String match();
+			String lastBreath();
+		}
+		
+		@Retention(RetentionPolicy.RUNTIME)
+		@Target({ElementType.TYPE})
+		@interface DeathMatchName注 {
+			String match();
+			String lastBreath();
+		}
+		
+		interface ꞱDentalClickNoise抽 extends Objectᴶᐩᐩ { // Africa type elevator smoke(abstract)
+		}
+		interface ꞱClassNameType抽 extends ꞱDentalClickNoise抽 {
+		}
+		interface ꞱClassScopeType抽 extends ꞱDentalClickNoise抽 {
+		}
+	}
+	
+	public enum ƉěꬵḭȵᶒClazzName {
+		;
+		@Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注(match = "Ʇ", lastBreath = "A african embedded type (elevator) must start with: ")
+		public interface ꞱPrefix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
+		}
+		@Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注(match = "ß", lastBreath = "A duytschen class must start with: ")
+		public interface ßPrefix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
+		}
+		@Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注(match = "Ɖěꬵḭȵᶒ", lastBreath = "A embedded definition class must start with: ")
+		public interface ƉěꬵḭȵᶒPrefix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
+		}
+		
+		@Ꝑŕḯṿª₮ḕ.DeathMatchPostfix注(match = "注", lastBreath = "A annatation class must end with: ")
+		public interface 注Postfix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
+		}
+		@Ꝑŕḯṿª₮ḕ.DeathMatchPostfix注(match = "邪ᙾ", lastBreath = "Every evil-is class must end with: ")
+		public interface 邪ᙾPostfix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
+		}
+		@Ꝑŕḯṿª₮ḕ.DeathMatchPostfix注(match = "抽", lastBreath = "An abstract interface or class must end with: ")
+		public interface 抽Postfix extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
+		}
+		
+		@Ꝑŕḯṿª₮ḕ.DeathMatchName注(match = "Ꝑŕḯṿª₮ḕ", lastBreath = "Inner class must be named private exactly: ")
+		public interface Ꝑŕḯṿª₮ḕName extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
+		}
+		@Ꝑŕḯṿª₮ḕ.DeathMatchName注(match = "Ꝑŕᱜṫèƈ₮ࠄ₫", lastBreath = "Inner class must be named protected exactly: ")
+		public interface Ꝑŕᱜṫèƈ₮ࠄ₫Name extends Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽 {
+		}
+	}
+	
+	public enum ƉěꬵḭȵᶒModifier {
+		;
+		public interface Ꝑŕḯṿª₮ḕ extends ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.ꞱClassScopeType抽, ObjectScopeLimitΔ.ƉěꬵḭȵᶒClazzName.Ꝑŕḯṿª₮ḕName {
+		}
+		public interface Ꝑŕᱜṫèƈ₮ࠄ₫ extends ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.ꞱClassScopeType抽, ObjectScopeLimitΔ.ƉěꬵḭȵᶒClazzName.Ꝑŕᱜṫèƈ₮ࠄ₫Name {
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectScopeLimitΔ邪ᙾ.java

@@ -0,0 +1,45 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.lang.instrument.IllegalClassFormatException;
+import java.security.ProtectionDomain;
+import java.util.Optional;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.DefaultBȍőnLoader;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©⍙ ∞ 仙上主天")
+public class ObjectScopeLimitΔ邪ᙾ implements ClassFileTransformer { 
+		
+	// not tested
+	@Override
+	public byte[] transform(Module module, ClassLoader loader, String className,
+			Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer)
+			throws IllegalClassFormatException {
+		if (!ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.ꞱClassNameType抽.class.isAssignableFrom(classBeingRedefined)) {
+			return null;
+		}
+		if (classBeingRedefined.getDeclaringClass() == null) {
+			return null;
+		}
+		Optional<Class<?>> checkPrefixInterface = DefaultBȍőnLoader.findInterfaceByAnnotation(classBeingRedefined, ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注.class);
+		if (checkPrefixInterface.isPresent()) {
+			ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注 checkPrefix = checkPrefixInterface.get().getAnnotation(ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchPrefix注.class);
+			if (checkPrefix != null) {
+				if (!classBeingRedefined.getName().startsWith(checkPrefix.match())) {
+					throw new IllegalClassFormatException(checkPrefix.lastBreath()+checkPrefix.match());
+				}
+			}
+		}
+		Optional<Class<?>> checkNameInterface = DefaultBȍőnLoader.findInterfaceByAnnotation(classBeingRedefined, ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchName注.class);
+		if (checkNameInterface.isPresent()) {
+			ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchName注 checkName = checkNameInterface.get().getAnnotation(ObjectScopeLimitΔ.Ꝑŕḯṿª₮ḕ.DeathMatchName注.class);
+			if (checkName != null) {
+				if (!classBeingRedefined.getName().equals(checkName.match())) {
+					throw new IllegalClassFormatException(checkName.lastBreath()+checkName.match());
+				}
+			}
+		}
+		return null;
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectSneeze.java

@@ -0,0 +1,51 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
+
+import java.util.Comparator;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface ObjectSneeze {
+	
+	// hatsjie = hashCode + compareTo + equals 
+	// hatsjie = dutch language of the sound of a sneeze
+	default long hatsjie(long sneezeSoundOther) {
+		// the caller handles obj null and thus zero is its own hashCode
+		long sneezeSound = hatsjieGodBlessYou(this);
+		if (sneezeSoundOther == 0) {
+			return sneezeSound;
+		}
+		return Long.compare(sneezeSound, sneezeSoundOther);
+	}
+	
+	public static long hatsjieGodBlessYou(Object soundSource) {
+		// default hashCode order is undefined normally.
+		// and is only required to be unique within a hash set.
+		String bassTone = soundSource.getClass().getName();
+		int overtones = bassTone.charAt(0);
+		if (bassTone.length() > 1) {
+			overtones += bassTone.charAt(1) << 8;
+		}
+		if (bassTone.length() > 2) {
+			overtones += bassTone.charAt(2) << 16;
+		}
+		if (bassTone.length() > 3) {
+			overtones += bassTone.charAt(3) << 24;
+		}
+		if (soundSource.getClass().isEnum()) {
+			//todo: check if jvm sys hash is already ordered for enum, else use this;
+			return (overtones << 32) + ((Enum<?>)soundSource).ordinal();
+		}
+		return (overtones << 32) + System.identityHashCode(soundSource);
+		// ^^ Default global ordering of all objects by ~name
+	}
+	
+	public static Comparator<ObjectSneeze> soundComparator() {
+		return new Comparator<ObjectSneeze>() {
+			@Override
+			public int compare(ObjectSneeze arg0, ObjectSneeze arg1) {
+				return (int) arg0.hatsjie(arg1.hatsjie(0));
+			}
+		};
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ObjectToHuman.java

@@ -0,0 +1,22 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringUnicode;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+/**
+ * Mark objects which need a English latin1 human output.
+ * 
+ * Human output can't be defined.
+ */
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface ObjectToHuman {
+	
+	// it looks like this was JMX in java version 1.0
+	String toString(); // the biggest mistake in java 
+	// thus for who in what format and which details...
+	
+	// Every computer needs brahmi support on strings
+	default StringUnicode toStringUnicode() {
+		return StringUnicode.valueOf(toString());
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/Objectᴶᐩᐩ.java

@@ -0,0 +1,14 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Objectᴶᐩᐩ extends ObjectSneeze {
+	
+	// humans are not allowed to code, who creates what ?
+	default Class<?> fromClass() {
+		// getters are for children of a bean
+		// not to return the mother of a bean
+		return getClass();
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/Object抽.java

@@ -0,0 +1,72 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+abstract public class Object抽 implements Objectᴶᐩᐩ {
+	
+	@Deprecated
+	@Override
+	public boolean equals(Object obj) {
+		if (obj == null) {
+			return false;
+		}
+		long compareSneeze = 0;
+		if (obj instanceof ObjectSneeze) {
+			compareSneeze = ObjectSneeze.class.cast(obj).hatsjie(0);
+		} else {
+			compareSneeze = ObjectSneeze.hatsjieGodBlessYou(obj);
+		}
+		return 0 == hatsjie(compareSneeze);
+	}
+	
+	@Deprecated
+	@Override
+	public int hashCode() {
+		return (int) hatsjie(0);
+	}
+	
+	@Deprecated
+	@Override
+	protected final Object clone() throws CloneNotSupportedException {
+		return super.clone();
+	}
+	
+	@Deprecated
+	@Override
+	protected final void finalize() throws Throwable {
+		super.finalize();
+	}
+	
+	@Deprecated
+	@Override
+	public String toString() {
+		return super.toString();
+	}
+	
+//  @Deprecated
+//	@Override
+//	public final void notify() throws IllegalMonitorStateException {
+//		super.notify();
+//	}
+//  @Deprecated
+//	@Override
+//	public final void notifyAll() throws IllegalMonitorStateException {
+//		super.notifyAll();
+//	}
+//  @Deprecated
+//	@Override
+//	public final void wait() throws InterruptedException {
+//		super.wait();
+//	}
+//	@Deprecated
+//	@Override
+//	public final void wait(long timeout) throws InterruptedException {
+//		super.wait(timeout);
+//	}
+//	@Deprecated
+//	@Override
+//	public final void wait(long timeout, int nanos) throws InterruptedException {
+//		super.wait(timeout, nanos);
+//	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/Runnableբ.java

@@ -0,0 +1,68 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelRussian;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Runnableբ extends Runnable, Babelizeբᴬᵖᶦ {
+	
+	@FunctionalInterface
+	interface זךזךזדןװ extends Runnableբ, BabelHinarī {
+		
+		@Override
+		default void run() {
+			יזױזזךזדןװיױ();
+		}
+		
+		void יזױזזךזדןװיױ();
+	}
+	
+	@FunctionalInterface
+	interface 可運行 extends Runnableբ, BabelMandarin {
+		
+		@Override
+		default void run() {
+			賽跑者();
+		}
+		
+		void 賽跑者();
+	}
+	
+	@FunctionalInterface
+	interface जंगम  extends Runnableբ, BabelHindi {
+		
+		@Override
+		default void run() {
+			दौड़ना();
+		}
+		
+		void दौड़ना();
+	}
+	
+	@FunctionalInterface
+	interface 𓌭𓀟 extends Runnableբ, BabelHiero {
+		
+		@Override
+		default void run() {
+			𓀟();
+		}
+		
+		void 𓀟();
+	}
+	
+	@FunctionalInterface
+	interface русский extends Runnableբ, BabelRussian {
+		
+		@Override
+		default void run() {
+			убегать();
+		}
+		
+		void убегать();
+	}
+}

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();
+	}
+}

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);
+	}
+}

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();
+	}
+}

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); } }
+	}
+}

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;
+		}
+	}
+}

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());
+	}
+}

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);
+	}
+}

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());
+	}
+}

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();
+//	}
+}

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());
+	}
+}

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);
+	}
+}

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);
+	}
+}

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);
+	}
+}

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);
+	}
+}

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);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelLocalizer.java

@@ -0,0 +1,89 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import java.lang.reflect.Method;
+import java.util.Locale;
+import java.util.Optional;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.DefaultBȍőnLoader;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocMethod注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocThrows注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocType注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDoc注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@DuytsDocType注(babel = {
+		@DuytsDoc注(locale= "en", purpose = "Base package interface from which a local language extends."),
+		@DuytsDoc注(locale= "zh", code = "通天塔龸定位器", purpose = "本地語言擴展的基礎包接口"),
+		@DuytsDoc注(locale= "hi", code = "कोलाहलꣻलोकलाइज़र", purpose = "बेस पैकेज इंटरफ़ेस जिससे एक स्थानीय भाषा का विस्तार होता है")
+})
+public interface BabelLocalizer { 
+// childface = JVM: only allow direct child members of this to use this interface
+// packface = JVM: only allow this package and subpackage are allowed to use this interface
+	
+	@DuytsDocMethod注(babel = {
+			@DuytsDoc注(locale= "en", purpose = "Retrieves the locale information"),
+			@DuytsDoc注(locale= "zh", code = "至龸通天塔龸定位器龸界面", purpose = "检索语言环境信息"),
+			@DuytsDoc注(locale= "hi", code = "बेबेलꣻलोकलाइज़रꣻकेꣻलिएꣻएपीआई", purpose = "स्थानीय जानकारी प्राप्त करता है")
+			}, exceptions = {
+				@DuytsDocThrows注(id = "missing_annotation", babel = {
+						@DuytsDoc注(locale= "en", code = "Missing required annotation @BabelLocalizer注 on interface: "),
+						@DuytsDoc注(locale= "zh", code = "缺少必需的註釋　@BabelLocalizer注　在界面上　"),
+						@DuytsDoc注(locale= "hi", code = "आवश्यक एनोटेशन गुम है @BabelLocalizer注 इंटरफ़ेस पर")
+				})
+			})
+	default BabelLocalizerᴬᵖᶦ toBabelLocalizerᴬᵖᶦ() {
+		Optional<Class<?>> loc = DefaultBȍőnLoader.findInterfaceByAnnotation(getClass(), BabelLocalizer注.class);
+		if (loc.isEmpty()) {
+			throw new RuntimeException(toBabelExceptionMessage("missing_annotation", "ascii", this));
+		}
+		BabelLocalizer注 anno = loc.get().getAnnotation(BabelLocalizer注.class);
+		return BabelLocalizerᴬᵖᶦ.Ꝑŕᱜṫèƈ₮ࠄ₫.instanceᴺᵉʷ(anno.name(), new Locale(anno.locale()), anno.target());
+	}
+	
+//	@DuytsDocMethod注(
+//			exceptions = {
+//				@DuytsDocThrows注(id = "missing_annotation",
+//						ascii = "Missing required annotation @BabelLocalizer注 on interface: %s",
+//						hindi = "आवश्यक एनोटेशन गुम है @BabelLocalizer注 इंटरफ़ेस पर %s",
+//						mandarin = "缺少必需的註釋　@BabelLocalizer注　在界面上　%s")
+//			})
+//	default void testException() {
+//		throw new RuntimeException(toBabelExceptionMessage("missing_annotation", this, "kooll...."));
+//	}
+	
+	public static String toBabelExceptionMessage(String exceptionId, BabelLocalizer loc, Object...msgArgs) {
+		BabelLocalizerᴬᵖᶦ api = loc.toBabelLocalizerᴬᵖᶦ();
+		return toBabelExceptionMessage(exceptionId, api.getLocale().getLanguage(), msgArgs);
+	}
+	
+	public static String toBabelExceptionMessage(String exceptionId, String localeId, Object...msgArgs) {
+		StackWalker walker = StackWalker.getInstance(StackWalker.Option.RETAIN_CLASS_REFERENCE);
+		StackWalker.StackFrame frame = walker.walk(stream1 -> stream1.skip(1).findFirst().orElse(null));
+		if (frame == null) {
+			throw new RuntimeException("No stackframe returned");
+		}
+		Class<?> callerClass = frame.getDeclaringClass();
+		Method callerMethod = null;
+		try {
+			callerMethod = callerClass.getMethod(frame.getMethodName(), frame.getMethodType().parameterArray());
+		} catch (NoSuchMethodException | SecurityException e) {
+			throw new RuntimeException(e);
+		}
+		DuytsDocMethod注 anno = callerMethod.getAnnotation(DuytsDocMethod注.class);
+		if (anno == null) {
+			throw new RuntimeException("Missing annotation @DuytsDocMethod注 on: "+callerMethod);
+		}
+		for (DuytsDocThrows注 error:anno.exceptions()) {
+			if (error.id().equals(exceptionId)) {
+				for (DuytsDoc注 duyts:error.babel()) {
+					if (duyts.locale().equals(localeId)) {
+						String errorMsg = String.format(duyts.code(), msgArgs);
+						throw new RuntimeException(errorMsg);
+					}
+				}
+			}
+		}
+		throw new RuntimeException("Missing exception id: "+exceptionId+" in @DuytsDocMethod注 on: "+callerMethod);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelLocalizerᴬᵖᶦ.java

@@ -0,0 +1,36 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import java.util.Locale;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BabelLocalizerᴬᵖᶦ {
+	
+	String getName();
+	
+	Locale getLocale();
+	
+	String getTarget();
+	
+	enum Ꝑŕᱜṫèƈ₮ࠄ₫ implements ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕᱜṫèƈ₮ࠄ₫ {
+		;
+		protected static BabelLocalizerᴬᵖᶦ instanceᴺᵉʷ(String name, Locale locale, String target) {
+			return new BabelLocalizerᴬᵖᶦ() {
+				@Override
+				public String getName() {
+					return name;
+				}
+				@Override
+				public Locale getLocale() {
+					return locale;
+				}
+				@Override
+				public String getTarget() {
+					return target;
+				}
+			};
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelLocalizer注.java

@@ -0,0 +1,20 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BabelLocalizer注 { 
+	
+	String name();
+	
+	String locale();
+	
+	String target();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelLocalizer邪ᙾ.java

@@ -0,0 +1,74 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import java.lang.instrument.ClassFileTransformer;
+import java.lang.instrument.IllegalClassFormatException;
+import java.lang.reflect.Method;
+import java.security.ProtectionDomain;
+import java.util.Optional;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.DefaultBȍőnLoader;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public class BabelLocalizer邪ᙾ implements ClassFileTransformer {
+	
+	// not tested
+	@Override
+	public byte[] transform(Module module, ClassLoader loader, String className,
+			Class<?> classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer)
+			throws IllegalClassFormatException {
+		if (!BabelLocalizer.class.isAssignableFrom(classBeingRedefined)) {
+			return null;
+		}
+		
+		// xxxᴬᵖᶦ objects
+		for (Class<?> embeddedClass:classBeingRedefined.getDeclaredClasses()) {
+			
+			// todo: check declared class, like this ?
+			if (Babelizeբᴬᵖᶦ.class.isAssignableFrom(classBeingRedefined) && BabelMethodƉěꬵḭȵᶒᴬᵖᶦ.class.isAssignableFrom(embeddedClass)) {
+				// check B
+			}
+			if (BabelMethodƉěꬵḭȵᶒᴬᵖᶦ.class.isAssignableFrom(classBeingRedefined) && BabelTypeTower抽.class.isAssignableFrom(embeddedClass)) {
+				// check T
+			}
+		}
+		
+		// babel translated object interfaces
+		Optional<Class<?>> checkMethodNameInterface = DefaultBȍőnLoader.findInterfaceByAnnotation(classBeingRedefined, BabelMethodNameEnforcer注.class);
+		if (checkMethodNameInterface.isEmpty()) {
+			return null;
+		}
+		BabelMethodNameEnforcer注 checkMethodName = checkMethodNameInterface.get().getAnnotation(BabelMethodNameEnforcer注.class);
+		if (checkMethodName == null) {
+			return null;
+		}
+		for (Method m:classBeingRedefined.getMethods()) {
+			if (m.getName().startsWith("toBabel")) {
+				continue;
+			}
+			boolean def = false;
+			for (Method mo:Object.class.getMethods()) { // java is evil, junk default methods....
+				if (m.getName().equals(mo.getName())) {
+					def = true;
+					break;
+				}
+			}
+			if (def) {
+				continue;
+			}
+			for (int c:m.getName().codePoints().toArray()) {
+				boolean allow = false;
+				for (BabelMethodNameRange注 range:checkMethodName.ranges()) {
+					if (c >= range.start() || c <= range.stop()) {
+						allow = true;
+						break;
+					}
+				}
+				if (!allow) {
+					throw new IllegalClassFormatException("Illegal unicode char in method name: "+m);
+				}
+			}
+		}
+		return null;
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelMethodNameEnforcer注.java

@@ -0,0 +1,16 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BabelMethodNameEnforcer注 {
+	
+	BabelMethodNameRange注[] ranges();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelMethodNameRange注.java

@@ -0,0 +1,18 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BabelMethodNameRange注 {
+	
+	int start();
+	int stop();
+	String name();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelMethodƉěꬵḭȵᶒᴬᵖᶦ.java

@@ -0,0 +1,45 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelAscii;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BabelMethodƉěꬵḭȵᶒᴬᵖᶦ extends BabelTypeTower抽 {
+
+	//define interface <Y> Y[]; // jvm: force child member definition of one-or-more
+	//inner interface <Y> Y;   // jvm: force child member definition of one
+	//inner enum <Y> Y;
+	//inner class <Y> Y;
+	
+	// Export to force api definitions in 3 languages
+	//define interfaces <Y extends DuytschenBabelLocaleChinaApi<?>> Y;
+	//define interfaces <Y extends DuytschenBabelLocaleBasicApi<?>> Y;
+	//define interfaces <Y extends DuytschenBabelLocaleEnglishApi<?>> Y;
+	// ^^^ for none duyts speakers get plain Ascii
+	
+	
+	// Force down a define result...
+	//abstract public BabelTypeTowerGuard export();
+	
+	public static
+		<
+			T1 extends BabelAscii,
+			T2 extends BabelMandarin,
+			T3 extends BabelHindi,
+			T4 extends BabelHiero,
+			T5 extends BabelHinarī
+		>
+		void
+			define5(
+				Class<? extends T1> t1,
+				Class<? extends T2> t2,
+				Class<? extends T3> t3,
+				Class<? extends T4> t4,
+				Class<? extends T5> t5
+				) {
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelTypeTowerReadßբᴬᵖᶦ.java

@@ -0,0 +1,10 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BabelTypeTowerReadßբᴬᵖᶦ<Q extends BabelTypeTowerReadßբᴬᵖᶦ<Q>> extends BabelTypeTower抽 {
+//public interface BabelTypeTowerReadբᴬᵖᶦ<T,Q extends BabelTypeTowerReadբᴬᵖᶦ<T,Q>> {
+	
+	/* protected */ Q toBabelᴿᵈ();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelTypeTowerWriteßբᴬᵖᶦ.java

@@ -0,0 +1,15 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BabelTypeTowerWriteßբᴬᵖᶦ<W extends BabelTypeTowerWriteßբᴬᵖᶦ<W,Q> & BabelTypeTowerReadßբᴬᵖᶦ<Q>, Q extends BabelTypeTowerReadßբᴬᵖᶦ<Q>> extends BabelTypeTowerReadßբᴬᵖᶦ<Q> {
+//public interface BabelTypeTowerWriteբᴬᵖᶦ<T,W extends BabelTypeTowerWriteբᴬᵖᶦ<T,W,Q> & BabelTypeTowerReadբᴬᵖᶦ<T,Q>, Q extends BabelTypeTowerReadբᴬᵖᶦ<T,Q>> extends BabelTypeTowerReadբᴬᵖᶦ<T,Q> {
+	
+	@SuppressWarnings("unchecked")
+	/* protected */ default Q toBabelᴿᵈ() {
+		return (Q) toBabelᵂʳ();
+	}
+	
+	/* protected */ W toBabelᵂʳ();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelTypeTowerßբᴬᵖᶦ.java

@@ -0,0 +1,9 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BabelTypeTowerßբᴬᵖᶦ<Q extends BabelTypeTowerßբᴬᵖᶦ<Q>> extends BabelTypeTower抽 {
+
+	/* protected */ Q toBabel();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelTypeTower抽.java

@@ -0,0 +1,13 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BabelTypeTower抽 extends
+	ObjectScopeLimitΔ.ƉěꬵḭȵᶒClazzName.ꞱPrefix,
+	ObjectScopeLimitΔ.ƉěꬵḭȵᶒClazzName.ßPrefix,
+	ObjectScopeLimitΔ.ƉěꬵḭȵᶒClazzName.ƉěꬵḭȵᶒPrefix {
+	
+	// note: naming scope is defined by parent interface
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/BabelTypeꝐŕḯṿª₮ḕᴬᵖᶦ.java

@@ -0,0 +1,7 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ObjectScopeLimitΔ;
+
+public interface BabelTypeꝐŕḯṿª₮ḕᴬᵖᶦ extends BabelTypeTower抽, ObjectScopeLimitΔ.ƉěꬵḭȵᶒModifier.Ꝑŕḯṿª₮ḕ {
+	// build (naming) structure helper marker
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/Babelizeբᴬᵖᶦ.java

@@ -0,0 +1,13 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface /* bassface */ Babelizeբᴬᵖᶦ {
+	
+	// note: used in functional interfaces thus only defaults
+//	default boolean toBassFaceᴬᵖᶦ() {
+//		// jvm: add support for bassface, to force default methods only.
+//		return getClass().getAnnotation(FunctionalInterface.class) != null;
+//	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ßբᴬᵖᶦ/BabelAscii.java

@@ -0,0 +1,10 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BabelLocalizer注(name = "Ascii", locale = "en", target = "Normalized boring company language")
+public interface BabelAscii extends BabelLocalizer {
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ßբᴬᵖᶦ/BabelHiero.java

@@ -0,0 +1,15 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelMethodNameEnforcer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelMethodNameRange注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BabelMethodNameEnforcer注(ranges = {
+		@BabelMethodNameRange注(start = 0x13000, stop = 0x1342F, name = "Egyptian Hieroglyphs")
+		})
+@BabelLocalizer注(name = "𓂀", locale = "en", target = "Orange Catholic Church pastors")
+public interface BabelHiero extends BabelLocalizer {
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ßբᴬᵖᶦ/BabelHinarī.java

@@ -0,0 +1,33 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelMethodNameEnforcer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelMethodNameRange注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BabelMethodNameEnforcer注(ranges = {
+		@BabelMethodNameRange注(start = 'ײ', stop = 'ײ', name = "Hebrew octal #1"),
+		@BabelMethodNameRange注(start = 'ױ', stop = 'ױ', name = "Hebrew octal #2"),
+		@BabelMethodNameRange注(start = 'ו', stop = 'ו', name = "Hebrew octal #3"),
+		@BabelMethodNameRange注(start = 'י', stop = 'י', name = "Hebrew octal #4"),
+		@BabelMethodNameRange注(start = 'ז', stop = 'ז', name = "Hebrew octal #5"),
+		@BabelMethodNameRange注(start = 'ד', stop = 'ד', name = "Hebrew octal #6"),
+		@BabelMethodNameRange注(start = 'ן', stop = 'ן', name = "Hebrew octal #7"),
+		@BabelMethodNameRange注(start = 'ך', stop = 'ך', name = "Hebrew octal #8")
+		})
+@BabelLocalizer注(name = "ヒナリー", locale = "ie", target = "Hardcore language for real hinarī coders")
+public interface BabelHinarī extends BabelLocalizer {
+	// Patre nor, qui es in li cieles,
+	// mey tui nómine esser sanctificat,
+	// mey tui regnia venir,
+	// mey tui vole esser fat,
+	// qualmen in li cieles talmen anc sur li terre.
+	// Da nos hodie nor pan omnidial,
+	// e pardona nor débites,
+	// qualmen anc noi pardona nor debitores.
+	// E ne inducte nos in tentation,
+	// ma libera nos de lu mal.
+	// Amen.
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ßբᴬᵖᶦ/BabelHindi.java

@@ -0,0 +1,25 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelMethodNameEnforcer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelMethodNameRange注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocType注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDoc注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@DuytsDocType注(babel = {
+		@DuytsDoc注(locale= "en", purpose = "Hindi class type identifier"),
+		@DuytsDoc注(locale= "zh", code = "通天塔龸印地語", purpose = "印地語類類型標識符"),
+		@DuytsDoc注(locale= "hi", code = "कोलाहलꣻहिन्दी", purpose = "हिंदी वर्ग प्रकार पहचानकर्ता")
+		})
+@BabelMethodNameEnforcer注(ranges = {
+		@BabelMethodNameRange注(start = 0x0900,  stop = 0x097F,  name = "Devanagari"),
+		@BabelMethodNameRange注(start = 0xA8E0,  stop = 0xA8FF,  name = "Devanagari Extended"),
+		@BabelMethodNameRange注(start = 0x11B00, stop = 0x11B09, name = "Devanagari Extended-A"),
+		@BabelMethodNameRange注(start = 0x1CD0,  stop = 0x1CFA,  name = "Vedic Extensions")
+		})
+@BabelLocalizer注(name = "हिन्दी", locale = "hi", target = "Seaking God with 1230 million eyes")
+public interface BabelHindi extends BabelLocalizer {
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ßբᴬᵖᶦ/BabelMandarin.java

@@ -0,0 +1,10 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BabelLocalizer注(name = "普通話", locale = "zh", target = "Dragon's nest has 2234 million bass noise ears")
+public interface BabelMandarin extends BabelLocalizer {
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ßբᴬᵖᶦ/BabelRussian.java

@@ -0,0 +1,10 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.BabelLocalizer注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BabelLocalizer注(name = "русский", locale = "ru", target = "Bãß rocket boot process")
+public interface BabelRussian extends BabelLocalizer {
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ᑊᐣᓑᖮᐪᔆ/DuytsDocAuthor注.java

@@ -0,0 +1,19 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Moves copyright into runtime class info.
+ */
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface DuytsDocAuthor注 {
+	
+	String name();
+	
+	String copyright();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ᑊᐣᓑᖮᐪᔆ/DuytsDocConstructor注.java

@@ -0,0 +1,18 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.CONSTRUCTOR})
+public @interface DuytsDocConstructor注 {
+	
+	// workflow for translators, set to true to flag this content should
+	// propagated to the other languages of the translatable doc item.
+	String awaitsPropagation() default "";
+	
+	DuytsDoc注[] babel();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ᑊᐣᓑᖮᐪᔆ/DuytsDocField注.java

@@ -0,0 +1,18 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.FIELD})
+public @interface DuytsDocField注 {
+	
+	// workflow for translators, set to true to flag this content should
+	// propagated to the other languages of the translatable doc item.
+	String awaitsPropagation() default "";
+	
+	DuytsDoc注[] babel();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ᑊᐣᓑᖮᐪᔆ/DuytsDocMethod注.java

@@ -0,0 +1,38 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@DuytsDocType注(babel = {
+		@DuytsDoc注(locale= "en", purpose = "Adds Duytschen documentation to a method"),
+		@DuytsDoc注(locale= "zh", code = "荷蘭文法", purpose = "將荷蘭文文檔添加到方法中"),
+		@DuytsDoc注(locale= "hi", code = "डचडॉकविधि", purpose = "एक विधि में डच दस्तावेज़ जोड़ता है")
+})
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface DuytsDocMethod注 {
+	
+	@DuytsDocMethod注(babel = {
+			@DuytsDoc注(locale= "en", purpose = "Translater workflow helper to mark propagation of text translations"),
+			@DuytsDoc注(locale= "zh", purpose = "用於標記文本翻譯傳播的翻譯工作流助手"),
+			@DuytsDoc注(locale= "hi", purpose = "पाठ अनुवादों के प्रसार को चिह्नित करने के लिए अनुवादक कार्यप्रवाह सहायक")
+			})
+	String awaitsPropagation() default "";
+	
+	@DuytsDocMethod注(babel = {
+			@DuytsDoc注(locale= "en", purpose = "All the translated language information of the annatated method"),
+			@DuytsDoc注(locale= "zh", purpose = "註釋方法的所有翻譯語言信息"),
+			@DuytsDoc注(locale= "hi", purpose = "एनाटेड विधि की सभी अनूदित भाषा की जानकारी")
+			})
+	DuytsDoc注[] babel();
+	
+	@DuytsDocMethod注(babel = {
+			@DuytsDoc注(locale= "en", purpose = "All the translated exceptions a method may throw"),
+			@DuytsDoc注(locale= "zh", purpose = "一個方法可能拋出的所有翻譯異常"),
+			@DuytsDoc注(locale= "hi", purpose = "सभी अनुवादित अपवाद एक विधि फेंक सकते हैं")
+			})
+	DuytsDocThrows注[] exceptions() default {};
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ᑊᐣᓑᖮᐪᔆ/DuytsDocThrows注.java

@@ -0,0 +1,16 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.METHOD})
+public @interface DuytsDocThrows注 {
+	
+	String id();
+	
+	DuytsDoc注[] babel();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ᑊᐣᓑᖮᐪᔆ/DuytsDocType注.java

@@ -0,0 +1,19 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface DuytsDocType注 {
+	
+	// workflow for translators, set to true to flag this content should
+	// propagated to the other languages of the translatable doc item.
+	//@DuytsDocMethod注
+	String awaitsPropagation() default "";
+	
+	DuytsDoc注[] babel();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒃᣔᒃᓫᒻ/ᑊᐣᓑᖮᐪᔆ/DuytsDoc注.java

@@ -0,0 +1,20 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.ANNOTATION_TYPE})
+public @interface DuytsDoc注 {
+	
+	String locale();
+	
+	String code() default "";
+	
+	String purpose() default "";
+	
+	String note() default "";
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᔾᓑᣕᒼᐪᑊᐤᣕᔆ/BiConsumerբ.java

@@ -0,0 +1,81 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᔾᓑᣕᒼᐪᑊᐤᣕᔆ;
+
+import java.util.function.BiConsumer;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BiConsumerբ<T,U> extends BiConsumer<T,U>, Babelizeբᴬᵖᶦ {
+	
+	void annehmen(T t,U u);
+	
+	@Override
+	default void accept(T t,U u) {
+		annehmen(t, u);
+	}
+	
+	@FunctionalInterface
+	interface ױזזױךיױךיך<יזזױזזז,יךיױ> extends BiConsumerբ<יזזױזזז,יךיױ>, BabelHinarī {
+		
+		@Override
+		default void annehmen(יזזױזזז ױז,יךיױ ךזז) {
+			זױזזז(ױז,ךזז);
+		}
+		
+		void זױזזז(יזזױזזז ױז,יךיױ ךזז);
+		
+		default ױזזױךיױךיך<יזזױזזז,יךיױ> זזזזױזזױךיךיזז(ױזזױךיױךיך<? super יזזױזזז,? super יךיױ> ױױזז) {
+			return (ױז,ךזז) -> ױזזױךיױךיך.this.andThen(ױױזז).accept(ױז, ךזז);
+		}
+	}
+	
+	@FunctionalInterface
+	interface 雙消費者<仿製藥,青蛙藥> extends BiConsumerբ<仿製藥,青蛙藥>, BabelMandarin {
+		
+		@Override
+		default void annehmen(仿製藥 物,青蛙藥 其他) {
+			接受(物,其他);
+		}
+		
+		void 接受(仿製藥 物,青蛙藥 其他);
+		
+		default 雙消費者<仿製藥,青蛙藥> 和龸接著(雙消費者<? super 仿製藥,? super 青蛙藥> 後) {
+			return (物,其他) -> 雙消費者.this.andThen(後).accept(物, 其他);
+		}
+	}
+	
+	@FunctionalInterface
+	interface दोहराꣻउपभोक्ता<जेनरिक,जम्पफ्रॉग> extends BiConsumerբ<जेनरिक,जम्पफ्रॉग>, BabelHindi {
+		
+		@Override
+		default void annehmen(जेनरिक चीज़,जम्पफ्रॉग अन्य) {
+			 मानना(चीज़,अन्य);
+		}
+		
+		void मानना(जेनरिक चीज़,जम्पफ्रॉग अन्य);
+		
+		default दोहराꣻउपभोक्ता<जेनरिक,जम्पफ्रॉग> औरꣻफिर(दोहराꣻउपभोक्ता<? super जेनरिक,? super जम्पफ्रॉग> पीछे) {
+			return (चीज़,अन्य) -> दोहराꣻउपभोक्ता.this.andThen(पीछे).accept(चीज़,अन्य);
+		}
+	}
+	
+	@FunctionalInterface
+	interface 𓇌𓀁<𓉢,𓉣> extends BiConsumerբ<𓉢,𓉣>, BabelHiero {
+		
+		@Override
+		default void annehmen(𓉢 𓐠,𓉣 𓐐) {
+			𓁉(𓐠,𓐐);
+		}
+		
+		void 𓁉(𓉢 𓐠,𓉣 𓐐);
+		
+		default 𓇌𓀁<𓉢,𓉣> 𓍰𓐗𓂐(𓇌𓀁<? super 𓉢,? super 𓉣> 𓅀) {
+			return (𓐠,𓐐) -> 𓇌𓀁.this.andThen(𓅀).accept(𓐠,𓐐);
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᔾᓑᣕᒼᐪᑊᐤᣕᔆ/Consumerբ.java

@@ -0,0 +1,81 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᔾᓑᣕᒼᐪᑊᐤᣕᔆ;
+
+import java.util.function.Consumer;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Consumerբ<T> extends Consumer<T>,Babelizeբᴬᵖᶦ {
+	
+	void annehmen(T t);
+	
+	@Override
+	default void accept(T t) {
+		annehmen(t);
+	}
+	
+	@FunctionalInterface
+	interface ךןךזױזןזױז<יזזױזזז> extends Consumerբ<יזזױזזז>, BabelHinarī {
+		
+		@Override
+		default void annehmen(יזזױזזז יךיױזזךז) {
+			יזדןזױזזזזך(יךיױזזךז);
+		}
+		
+		void יזדןזױזזזזך(יזזױזזז יךיױזזךז);
+		
+		default ךןךזױזןזױז<יזזױזזז> זדןזױזזזזױזזז(ךןךזױזןזױז<? super יזזױזזז> יךיױזזךז) {
+			return (װװ) -> ךןךזױזןזױז.this.andThen(יךיױזזךז).accept(װװ);
+		}
+	}
+	
+	@FunctionalInterface
+	interface 消費者<仿製藥> extends Consumerբ<仿製藥>, BabelMandarin {
+		
+		@Override
+		default void annehmen(仿製藥 物) {
+			接受(物);
+		}
+		
+		void 接受(仿製藥 物);
+		
+		default 消費者<仿製藥> 和龸接著(消費者<? super 仿製藥> 後) {
+			return (物) -> 消費者.this.andThen(後).accept(物);
+		}
+	}
+	
+	@FunctionalInterface
+	interface उपभोक्ता<जेनरिक> extends Consumerբ<जेनरिक>, BabelHindi {
+		
+		@Override
+		default void annehmen(जेनरिक चीज़) {
+			मानना(चीज़);
+		}
+		
+		void मानना(जेनरिक चीज़);
+		
+		default उपभोक्ता<जेनरिक> औरꣻफिर(उपभोक्ता<? super जेनरिक> पीछे) {
+			return (चीज़) -> उपभोक्ता.this.andThen(पीछे).accept(चीज़);
+		}
+	}
+	
+	@FunctionalInterface
+	interface 𓀁𓏁<𓉢> extends Consumerբ<𓉢>, BabelHiero {
+		
+		@Override
+		default void annehmen(𓉢 𓐠) {
+			𓁉(𓐠);
+		}
+		
+		void 𓁉(𓉢 𓐠);
+		
+		default 𓀁𓏁<𓉢> 𓍰𓐗𓂐(𓀁𓏁<? super 𓉢> 𓅀) {
+			return (𓐠) -> 𓀁𓏁.this.andThen(𓅀).accept(𓐠);
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᔾᓑᣕᒼᐪᑊᐤᣕᔆ/Functionբ.java

@@ -0,0 +1,133 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᔾᓑᣕᒼᐪᑊᐤᣕᔆ;
+
+import java.util.function.Function;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Functionբ<T,R> extends Function<T,R>, Babelizeբᴬᵖᶦ {
+	
+	R ausführen(T t);
+	
+	@Override
+	default R apply(T t) {
+		return ausführen(t);
+	}
+	
+	@FunctionalInterface
+	interface ױױױיךיזזז<יזזױזזז,יךיױ> extends Functionբ<יזזױזזז,יךיױ>, BabelHinarī {
+		
+		@Override
+		default יךיױ ausführen(יזזױזזז ױז) {
+			return זױױזזזױזז(ױז);
+		}
+		
+		יךיױ זױױזזזױזז(יזזױזזז ױז);
+		
+		default <זױךי> ױױױיךיזזז<יזזױזזז,זױךי> זזזזױזזױךיךיזז(ױױױיךיזזז<? super יךיױ,? extends זױךי> ױױזז) {
+			return (זױךיךי) -> ױױױיךיזזז.this.andThen(ױױזז).apply(זױךיךי);
+		}
+		
+		default <זױךי> ױױױיךיזזז<זױךי,יךיױ> זזזױךיךיזזױזזז(ױױױיךיזזז<? super זױךי,? extends יזזױזזז> זזױױ) {
+			return (זױךיךי) -> ױױױיךיזזז.this.compose(זזױױ).apply(זױךיךי);
+		}
+		
+		static <יזזױזזז> ױױױיךיזזז<יזזױזזז,יזזױזזז> זזזױױזזױזז() {
+			return new ױױױיךיזזז<>() {
+				@Override
+				public יזזױזזז זױױזזזױזז(יזזױזזז ױז) {
+					return ױז;
+				}
+			};
+		}
+	}
+	
+	@FunctionalInterface
+	interface 功能<仿製藥,青蛙藥> extends Functionբ<仿製藥,青蛙藥>, BabelMandarin {
+		
+		@Override
+		default 青蛙藥 ausführen(仿製藥 物) {
+			return 接受(物);
+		}
+		
+		青蛙藥 接受(仿製藥 物);
+		
+		default <蛋從> 功能<仿製藥,蛋從> 和龸接著(功能<? super 青蛙藥,? extends 蛋從> 後) {
+			return (物) -> 功能.this.andThen(後).apply(物);
+		}
+		
+		default <蛋從> 功能<蛋從,青蛙藥> 構成前(功能<? super 蛋從,? extends 仿製藥> 字首) {
+			return (物) -> 功能.this.compose(字首).apply(物);
+		}
+		
+		static <仿製藥> 功能<仿製藥,仿製藥> 身份() {
+			return new 功能<>() {
+				@Override
+				public 仿製藥 接受(仿製藥 物) {
+					return 物;
+				}
+			};
+		}
+	}
+	
+	@FunctionalInterface
+	interface काम<जेनरिक,जम्पफ्रॉग> extends Functionբ<जेनरिक,जम्पफ्रॉग>, BabelHindi {
+		
+		@Override
+		default जम्पफ्रॉग ausführen(जेनरिक चीज़) {
+			 return मानना(चीज़);
+		}
+		
+		जम्पफ्रॉग मानना(जेनरिक चीज़);
+		
+		default <अंडाफ> काम<जेनरिक,अंडाफ> औरꣻफिर(काम<? super जम्पफ्रॉग,? extends अंडाफ> पीछे) {
+			return (चीज़) -> काम.this.andThen(पीछे).apply(चीज़);
+		}
+		
+		default <अंडाफ> काम<अंडाफ,जम्पफ्रॉग> पहलाकर्ता(काम<? super अंडाफ,? extends जेनरिक> हैडर) {
+			return (चीज़) -> काम.this.compose(हैडर).apply(चीज़);
+		}
+		
+		static <जेनरिक> काम<जेनरिक,जेनरिक> पहचान() {
+			return new काम<जेनरिक, जेनरिक>() {
+				@Override
+				public जेनरिक मानना(जेनरिक चीज़) {
+					return चीज़;
+				}
+			};
+		}
+	}
+	
+	@FunctionalInterface
+	interface 𓁟𓎓𓄟<𓉢,𓉣> extends Functionբ<𓉢,𓉣>, BabelHiero {
+		
+		@Override
+		default 𓉣 ausführen(𓉢 𓐠) {
+			return 𓁉(𓐠);
+		}
+		
+		𓉣 𓁉(𓉢 𓐠);
+		
+		default <𓉡> 𓁟𓎓𓄟<𓉢,𓉡> 𓍰𓐗𓂐(𓁟𓎓𓄟<? super 𓉣,? extends 𓉡> 𓅀) {
+			return (𓐠) -> 𓁟𓎓𓄟.this.andThen(𓅀).apply(𓐠);
+		}
+		
+		default <𓉡> 𓁟𓎓𓄟<𓉡,𓉣> 𓆥(𓁟𓎓𓄟<? super 𓉡,? extends 𓉢> 𓅽) {
+			return (𓐠) -> 𓁟𓎓𓄟.this.compose(𓅽).apply(𓐠);
+		}
+		
+		static <𓉢> 𓁟𓎓𓄟<𓉢,𓉢> 𓀀() {
+			return new 𓁟𓎓𓄟<>() {
+				@Override
+				public 𓉢 𓁉(𓉢 𓐠) {
+					return 𓐠;
+				}
+			};
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᔾᓑᣕᒼᐪᑊᐤᣕᔆ/Supplierբ.java

@@ -0,0 +1,65 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᔾᓑᣕᒼᐪᑊᐤᣕᔆ;
+
+import java.util.function.Supplier;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Supplierբ<T> extends Supplier<T>, Babelizeբᴬᵖᶦ {
+	
+	T abholen();
+	
+	@Override
+	default T get() {
+		return abholen();
+	}
+	
+	@FunctionalInterface
+	interface זזױױזדױךז<יזזױזזז> extends Supplierբ<יזזױזזז>, BabelHinarī {
+		
+		@Override
+		default יזזױזזז abholen() {
+			return יזױזדזזזןזדןזך();
+		}
+		
+		יזזױזזז יזױזדזזזןזדןזך();
+	}
+	
+	@FunctionalInterface
+	interface 供應商<仿製藥> extends Supplierբ<仿製藥>, BabelMandarin {
+		
+		@Override
+		default 仿製藥 abholen() {
+			return 得到();
+		}
+		
+		仿製藥 得到();
+	}
+	
+	@FunctionalInterface
+	interface प्रदायक<जेनरिक> extends Supplierբ<जेनरिक>, BabelHindi {
+		
+		@Override
+		default जेनरिक abholen() {
+			return प्राप्त();
+		}
+		
+		जेनरिक प्राप्त();
+	}
+	
+	@FunctionalInterface
+	interface 𓊷𓉭𓆅<𓉢> extends Supplierբ<𓉢>, BabelHiero {
+		
+		@Override
+		default 𓉢 abholen() {
+			return 𓀦();
+		}
+		
+		𓉢 𓀦();
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/BaseNumber.java

@@ -0,0 +1,12 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ.PrimitiveBooleanIterator;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BaseNumber {
+	
+	PrimitiveBooleanIterator toIteratorBoolean();
+	
+	//NumberStepIterator toIteratorNumberStep(NumberValue stepSize);
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/BaseNumberBlob.java

@@ -0,0 +1,44 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ;
+
+import java.math.BigInteger;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Consumer;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ.M02MatrixBinary;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BaseNumberBlob extends BaseNumber /*extends Iterable<NumberValue.NumberValueStep>*/ {
+	
+	default Iterator<NumberValueStep> toBlobIterator(M02MatrixBinary order) {
+		List<Byte> bytes = new ArrayList<>();
+		toIteratorBoolean().toByteIterator(order).forEachRemaining((Consumer<? super Byte>)v -> {
+			bytes.add(v);
+		});
+		byte[] byteArray = new byte[bytes.size()];
+		for (int i=0;i<byteArray.length;i++) {
+			byteArray[i] = bytes.get(i);
+		}
+		return new Iterator<BaseNumberBlob.NumberValueStep>() {
+			private BigInteger value = new BigInteger(byteArray);
+			
+			@Override
+			public NumberValueStep next() {
+				value = value.subtract(BigInteger.ONE);
+				return NumberValueStep.ONE;
+			}
+			
+			@Override
+			public boolean hasNext() {
+				return value.compareTo(BigInteger.ZERO) != Bãß.ℭỗᶇṧⱦᶏꬼȶʂ.INT_ZERO;
+			}
+		};
+	}
+	
+	interface NumberValueStep {
+		public static final NumberValueStep ONE = new NumberValueStep() {};
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/BaseNumberByte.java

@@ -0,0 +1,10 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ.PrimitiveByteIterator;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface BaseNumberByte extends BaseNumber {
+	
+	PrimitiveByteIterator toIteratorByte();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/BãßBȍőnNumberMatrixʸᴰ.java

@@ -0,0 +1,55 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnAnnotation注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytsFlüstern注;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.ᣖᑊᣗᣔᐪᓫ.BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒄᓫᣔᐪᑋ.ᔆᣖᑊᒄᓫᣗ.BãßBȍőnSpiderWire注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᐪᓫᕽᐪ.StringGhostKey;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᔿᐤᒄʸ.ᣔᒃᣔᒼᓑᔆ.BãßBȍőnAbacusEnumBase響ᴼᶠ;
+import ᒢᐩᐩ.ᔿᐤᒄʸ.ᣔᒃᣔᒼᓑᔆ.BãßBȍőnAbacusSetʸᴰ;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnDuytsFlüstern注(purpose = "Holds the number block and dimension.")
+@BãßBȍőnAnnotation注(required = {BãßBȍőnNumberMatrix注.class})
+public interface BãßBȍőnNumberMatrixʸᴰ<T extends BãßBȍőnNumberMatrixʸᴰ<T>> extends BãßBȍőnAbacusSetʸᴰ<T> {
+
+	public static final class Ꝑŕḯṿª₮ḕ implements BãßBȍőnꝐŕḯṿª₮ḕ {
+		private static final StringGhostKey GHOST_MATRIX_DIMENSION = StringGhostKey.asciiᴳʰᵒˢᵗ();
+		private static final StringGhostKey GHOST_NUMBER_BLOCK = StringGhostKey.asciiᴳʰᵒˢᵗ();
+		
+		@BãßBȍőnSpiderWire注
+		private BãßBȍőnNumberMatrixʸᴰ<?> boon;
+		
+		@Override
+		public BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ.Void init() {
+			BãßBȍőnNumberMatrix注 anno = boon.getClass().getAnnotation(BãßBȍőnNumberMatrix注.class);
+			boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST(GHOST_MATRIX_DIMENSION, anno.dimension());
+			return BãßBȍőnꝐŕḯṿª₮ḕ響ᴼᶠ.Void.實施;
+		}
+		
+		@SafeVarargs
+		public static <Y extends BãßBȍőnNumberMatrixʸᴰ<Y>> void יהוהʸᴰ(Y boon, String dialTone, int...args) {
+			Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.𓂀ױןייזדזיודזיןןזזזןױ𓉢(boon);
+			boon.toBBC().NOISE_OF(BãßBȍőnAbacusEnumBase響ᴼᶠ.class).rȧñkRingToonInluiden(dialTone);
+			boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).PUT_GHOST_LIST(GHOST_NUMBER_BLOCK);
+			for (int arg:args) {
+				boon.toBBC().UNHOLY_SPELL(Ꝑŕḯṿª₮ḕ.class).GHOST_LIST_INT(GHOST_NUMBER_BLOCK).add(arg);
+			}
+		}
+	}
+	
+	default int teŀráàmMatrixDimensie() {
+		return toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_INT(Ꝑŕḯṿª₮ḕ.GHOST_MATRIX_DIMENSION);
+	}
+	
+	default int rȧñkNummerBlokGroote() {
+		return toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_LIST_INT(Ꝑŕḯṿª₮ḕ.GHOST_NUMBER_BLOCK).size();
+	}
+	
+	default int rȧñkNummerBlokWaarde(int index) {
+		return toBBC().UNHOLY(Ꝑŕḯṿª₮ḕ.class).GHOST_LIST_INT(Ꝑŕḯṿª₮ḕ.GHOST_NUMBER_BLOCK).get(index);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/BãßBȍőnNumberMatrix注.java

@@ -0,0 +1,16 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Retention(RetentionPolicy.RUNTIME)
+@Target({ElementType.TYPE})
+public @interface BãßBȍőnNumberMatrix注 {
+
+	int dimension();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/M02MatrixBinary.java

@@ -0,0 +1,18 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnNumberMatrix注(dimension = 2)
+public enum M02MatrixBinary implements BãßBȍőnNumberMatrixʸᴰ<M02MatrixBinary> {
+	M_01("0x1",1,0),
+	M_02("0x2",0,1),
+	;
+	
+	public final static M02MatrixBinary STATIC = M02MatrixBinary.M_01;
+	public final static M02MatrixBinary TAIL = STATIC.rȧñkNaarLaatste();
+	
+	private M02MatrixBinary(String dialTone, int...args) {
+		BãßBȍőnNumberMatrixʸᴰ.Ꝑŕḯṿª₮ḕ.יהוהʸᴰ(this, dialTone, args);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/M03MatrixTrit.java

@@ -0,0 +1,22 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnNumberMatrix注(dimension = 3)
+public enum M03MatrixTrit implements BãßBȍőnNumberMatrixʸᴰ<M03MatrixTrit> {
+	M_005("0x05",2,1,0),
+	M_007("0x07",1,2,0),
+	M_011("0x0B",2,0,1),
+	M_015("0x0F",0,2,1),
+	M_019("0x13",1,0,2),
+	M_021("0x15",0,1,2),
+	;
+	
+	public final static M03MatrixTrit STATIC = M03MatrixTrit.M_005;
+	public final static M03MatrixTrit TAIL = STATIC.rȧñkNaarLaatste();
+	
+	private M03MatrixTrit(String dialTone, int...args) {
+		BãßBȍőnNumberMatrixʸᴰ.Ꝑŕḯṿª₮ḕ.יהוהʸᴰ(this, dialTone, args);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/M04MatrixQuad.java

@@ -0,0 +1,40 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnNumberMatrix注(dimension = 4)
+public enum M04MatrixQuad implements BãßBȍőnNumberMatrixʸᴰ<M04MatrixQuad> {
+	M_0027("0x01B",3,2,1,0),
+	M_0030("0x01E",2,3,1,0),
+	M_0039("0x027",3,1,2,0),
+	M_0045("0x02D",1,3,2,0),
+	M_0054("0x036",2,1,3,0),
+	M_0057("0x039",1,2,3,0),
+	M_0075("0x04B",3,2,0,1),
+	M_0078("0x04E",2,3,0,1),
+	M_0099("0x063",3,0,2,1),
+	M_0108("0x06C",0,3,2,1),
+	M_0114("0x072",2,0,3,1),
+	M_0120("0x078",0,2,3,1),
+	M_0135("0x087",3,1,0,2),
+	M_0141("0x08D",1,3,0,2),
+	M_0147("0x093",3,0,1,2),
+	M_0156("0x09C",0,3,1,2),
+	M_0177("0x0B1",1,0,3,2),
+	M_0180("0x0B4",0,1,3,2),
+	M_0198("0x0C6",2,1,0,3),
+	M_0201("0x0C9",1,2,0,3),
+	M_0210("0x0D2",2,0,1,3),
+	M_0216("0x0D8",0,2,1,3),
+	M_0225("0x0E1",1,0,2,3),
+	M_0228("0x0E4",0,1,2,3),
+	;
+	
+	public final static M04MatrixQuad STATIC = M04MatrixQuad.M_0027;
+	public final static M04MatrixQuad TAIL = STATIC.rȧñkNaarLaatste();
+	
+	private M04MatrixQuad(String dialTone, int...args) {
+		BãßBȍőnNumberMatrixʸᴰ.Ꝑŕḯṿª₮ḕ.יהוהʸᴰ(this, dialTone, args);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/M05MatrixPental.java

@@ -0,0 +1,136 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnNumberMatrix注(dimension = 5)
+public enum M05MatrixPental implements BãßBȍőnNumberMatrixʸᴰ<M05MatrixPental> {
+	M_00194("0x00C2",4,3,2,1,0),
+	M_00198("0x00C6",3,4,2,1,0),
+	M_00214("0x00D6",4,2,3,1,0),
+	M_00222("0x00DE",2,4,3,1,0),
+	M_00238("0x00EE",3,2,4,1,0),
+	M_00242("0x00F2",2,3,4,1,0),
+	M_00294("0x0126",4,3,1,2,0),
+	M_00298("0x012A",3,4,1,2,0),
+	M_00334("0x014E",4,1,3,2,0),
+	M_00346("0x015A",1,4,3,2,0),
+	M_00358("0x0166",3,1,4,2,0),
+	M_00366("0x016E",1,3,4,2,0),
+	M_00414("0x019E",4,2,1,3,0),
+	M_00422("0x01A6",2,4,1,3,0),
+	M_00434("0x01B2",4,1,2,3,0),
+	M_00446("0x01BE",1,4,2,3,0),
+	M_00482("0x01E2",2,1,4,3,0),
+	M_00486("0x01E6",1,2,4,3,0),
+	M_00538("0x021A",3,2,1,4,0),
+	M_00542("0x021E",2,3,1,4,0),
+	M_00558("0x022E",3,1,2,4,0),
+	M_00566("0x0236",1,3,2,4,0),
+	M_00582("0x0246",2,1,3,4,0),
+	M_00586("0x024A",1,2,3,4,0),
+	M_00694("0x02B6",4,3,2,0,1),
+	M_00698("0x02BA",3,4,2,0,1),
+	M_00714("0x02CA",4,2,3,0,1),
+	M_00722("0x02D2",2,4,3,0,1),
+	M_00738("0x02E2",3,2,4,0,1),
+	M_00742("0x02E6",2,3,4,0,1),
+	M_00894("0x037E",4,3,0,2,1),
+	M_00898("0x0382",3,4,0,2,1),
+	M_00954("0x03BA",4,0,3,2,1),
+	M_00970("0x03CA",0,4,3,2,1),
+	M_00978("0x03D2",3,0,4,2,1),
+	M_00990("0x03DE",0,3,4,2,1),
+	M_01014("0x03F6",4,2,0,3,1),
+	M_01022("0x03FE",2,4,0,3,1),
+	M_01054("0x041E",4,0,2,3,1),
+	M_01070("0x042E",0,4,2,3,1),
+	M_01102("0x044E",2,0,4,3,1),
+	M_01110("0x0456",0,2,4,3,1),
+	M_01138("0x0472",3,2,0,4,1),
+	M_01142("0x0476",2,3,0,4,1),
+	M_01178("0x049A",3,0,2,4,1),
+	M_01190("0x04A6",0,3,2,4,1),
+	M_01202("0x04B2",2,0,3,4,1),
+	M_01210("0x04BA",0,2,3,4,1),
+	M_01294("0x050E",4,3,1,0,2),
+	M_01298("0x0512",3,4,1,0,2),
+	M_01334("0x0536",4,1,3,0,2),
+	M_01346("0x0542",1,4,3,0,2),
+	M_01358("0x054E",3,1,4,0,2),
+	M_01366("0x0556",1,3,4,0,2),
+	M_01394("0x0572",4,3,0,1,2),
+	M_01398("0x0576",3,4,0,1,2),
+	M_01454("0x05AE",4,0,3,1,2),
+	M_01470("0x05BE",0,4,3,1,2),
+	M_01478("0x05C6",3,0,4,1,2),
+	M_01490("0x05D2",0,3,4,1,2),
+	M_01634("0x0662",4,1,0,3,2),
+	M_01646("0x066E",1,4,0,3,2),
+	M_01654("0x0676",4,0,1,3,2),
+	M_01670("0x0686",0,4,1,3,2),
+	M_01726("0x06BE",1,0,4,3,2),
+	M_01730("0x06C2",0,1,4,3,2),
+	M_01758("0x06DE",3,1,0,4,2),
+	M_01766("0x06E6",1,3,0,4,2),
+	M_01778("0x06F2",3,0,1,4,2),
+	M_01790("0x06FE",0,3,1,4,2),
+	M_01826("0x0722",1,0,3,4,2),
+	M_01830("0x0726",0,1,3,4,2),
+	M_01914("0x077A",4,2,1,0,3),
+	M_01922("0x0782",2,4,1,0,3),
+	M_01934("0x078E",4,1,2,0,3),
+	M_01946("0x079A",1,4,2,0,3),
+	M_01982("0x07BE",2,1,4,0,3),
+	M_01986("0x07C2",1,2,4,0,3),
+	M_02014("0x07DE",4,2,0,1,3),
+	M_02022("0x07E6",2,4,0,1,3),
+	M_02054("0x0806",4,0,2,1,3),
+	M_02070("0x0816",0,4,2,1,3),
+	M_02102("0x0836",2,0,4,1,3),
+	M_02110("0x083E",0,2,4,1,3),
+	M_02134("0x0856",4,1,0,2,3),
+	M_02146("0x0862",1,4,0,2,3),
+	M_02154("0x086A",4,0,1,2,3),
+	M_02170("0x087A",0,4,1,2,3),
+	M_02226("0x08B2",1,0,4,2,3),
+	M_02230("0x08B6",0,1,4,2,3),
+	M_02382("0x094E",2,1,0,4,3),
+	M_02386("0x0952",1,2,0,4,3),
+	M_02402("0x0962",2,0,1,4,3),
+	M_02410("0x096A",0,2,1,4,3),
+	M_02426("0x097A",1,0,2,4,3),
+	M_02430("0x097E",0,1,2,4,3),
+	M_02538("0x09EA",3,2,1,0,4),
+	M_02542("0x09EE",2,3,1,0,4),
+	M_02558("0x09FE",3,1,2,0,4),
+	M_02566("0x0A06",1,3,2,0,4),
+	M_02582("0x0A16",2,1,3,0,4),
+	M_02586("0x0A1A",1,2,3,0,4),
+	M_02638("0x0A4E",3,2,0,1,4),
+	M_02642("0x0A52",2,3,0,1,4),
+	M_02678("0x0A76",3,0,2,1,4),
+	M_02690("0x0A82",0,3,2,1,4),
+	M_02702("0x0A8E",2,0,3,1,4),
+	M_02710("0x0A96",0,2,3,1,4),
+	M_02758("0x0AC6",3,1,0,2,4),
+	M_02766("0x0ACE",1,3,0,2,4),
+	M_02778("0x0ADA",3,0,1,2,4),
+	M_02790("0x0AE6",0,3,1,2,4),
+	M_02826("0x0B0A",1,0,3,2,4),
+	M_02830("0x0B0E",0,1,3,2,4),
+	M_02882("0x0B42",2,1,0,3,4),
+	M_02886("0x0B46",1,2,0,3,4),
+	M_02902("0x0B56",2,0,1,3,4),
+	M_02910("0x0B5E",0,2,1,3,4),
+	M_02926("0x0B6E",1,0,2,3,4),
+	M_02930("0x0B72",0,1,2,3,4),
+	;
+	
+	public final static M05MatrixPental STATIC = M05MatrixPental.M_00194;
+	public final static M05MatrixPental TAIL = STATIC.rȧñkNaarLaatste();
+	
+	private M05MatrixPental(String dialTone, int...args) {
+		BãßBȍőnNumberMatrixʸᴰ.Ꝑŕḯṿª₮ḕ.יהוהʸᴰ(this, dialTone, args);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/M06MatrixSeximal.java

@@ -0,0 +1,736 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnNumberMatrix注(dimension = 6)
+public enum M06MatrixSeximal implements BãßBȍőnNumberMatrixʸᴰ<M06MatrixSeximal> {
+	M_001865("0x00749",5,4,3,2,1,0),
+	M_001870("0x0074E",4,5,3,2,1,0),
+	M_001895("0x00767",5,3,4,2,1,0),
+	M_001905("0x00771",3,5,4,2,1,0),
+	M_001930("0x0078A",4,3,5,2,1,0),
+	M_001935("0x0078F",3,4,5,2,1,0),
+	M_002045("0x007FD",5,4,2,3,1,0),
+	M_002050("0x00802",4,5,2,3,1,0),
+	M_002105("0x00839",5,2,4,3,1,0),
+	M_002120("0x00848",2,5,4,3,1,0),
+	M_002140("0x0085C",4,2,5,3,1,0),
+	M_002150("0x00866",2,4,5,3,1,0),
+	M_002255("0x008CF",5,3,2,4,1,0),
+	M_002265("0x008D9",3,5,2,4,1,0),
+	M_002285("0x008ED",5,2,3,4,1,0),
+	M_002300("0x008FC",2,5,3,4,1,0),
+	M_002355("0x00933",3,2,5,4,1,0),
+	M_002360("0x00938",2,3,5,4,1,0),
+	M_002470("0x009A6",4,3,2,5,1,0),
+	M_002475("0x009AB",3,4,2,5,1,0),
+	M_002500("0x009C4",4,2,3,5,1,0),
+	M_002510("0x009CE",2,4,3,5,1,0),
+	M_002535("0x009E7",3,2,4,5,1,0),
+	M_002540("0x009EC",2,3,4,5,1,0),
+	M_002945("0x00B81",5,4,3,1,2,0),
+	M_002950("0x00B86",4,5,3,1,2,0),
+	M_002975("0x00B9F",5,3,4,1,2,0),
+	M_002985("0x00BA9",3,5,4,1,2,0),
+	M_003010("0x00BC2",4,3,5,1,2,0),
+	M_003015("0x00BC7",3,4,5,1,2,0),
+	M_003305("0x00CE9",5,4,1,3,2,0),
+	M_003310("0x00CEE",4,5,1,3,2,0),
+	M_003395("0x00D43",5,1,4,3,2,0),
+	M_003415("0x00D57",1,5,4,3,2,0),
+	M_003430("0x00D66",4,1,5,3,2,0),
+	M_003445("0x00D75",1,4,5,3,2,0),
+	M_003515("0x00DBB",5,3,1,4,2,0),
+	M_003525("0x00DC5",3,5,1,4,2,0),
+	M_003575("0x00DF7",5,1,3,4,2,0),
+	M_003595("0x00E0B",1,5,3,4,2,0),
+	M_003645("0x00E3D",3,1,5,4,2,0),
+	M_003655("0x00E47",1,3,5,4,2,0),
+	M_003730("0x00E92",4,3,1,5,2,0),
+	M_003735("0x00E97",3,4,1,5,2,0),
+	M_003790("0x00ECE",4,1,3,5,2,0),
+	M_003805("0x00EDD",1,4,3,5,2,0),
+	M_003825("0x00EF1",3,1,4,5,2,0),
+	M_003835("0x00EFB",1,3,4,5,2,0),
+	M_004205("0x0106D",5,4,2,1,3,0),
+	M_004210("0x01072",4,5,2,1,3,0),
+	M_004265("0x010A9",5,2,4,1,3,0),
+	M_004280("0x010B8",2,5,4,1,3,0),
+	M_004300("0x010CC",4,2,5,1,3,0),
+	M_004310("0x010D6",2,4,5,1,3,0),
+	M_004385("0x01121",5,4,1,2,3,0),
+	M_004390("0x01126",4,5,1,2,3,0),
+	M_004475("0x0117B",5,1,4,2,3,0),
+	M_004495("0x0118F",1,5,4,2,3,0),
+	M_004510("0x0119E",4,1,5,2,3,0),
+	M_004525("0x011AD",1,4,5,2,3,0),
+	M_004805("0x012C5",5,2,1,4,3,0),
+	M_004820("0x012D4",2,5,1,4,3,0),
+	M_004835("0x012E3",5,1,2,4,3,0),
+	M_004855("0x012F7",1,5,2,4,3,0),
+	M_004940("0x0134C",2,1,5,4,3,0),
+	M_004945("0x01351",1,2,5,4,3,0),
+	M_005020("0x0139C",4,2,1,5,3,0),
+	M_005030("0x013A6",2,4,1,5,3,0),
+	M_005050("0x013BA",4,1,2,5,3,0),
+	M_005065("0x013C9",1,4,2,5,3,0),
+	M_005120("0x01400",2,1,4,5,3,0),
+	M_005125("0x01405",1,2,4,5,3,0),
+	M_005495("0x01577",5,3,2,1,4,0),
+	M_005505("0x01581",3,5,2,1,4,0),
+	M_005525("0x01595",5,2,3,1,4,0),
+	M_005540("0x015A4",2,5,3,1,4,0),
+	M_005595("0x015DB",3,2,5,1,4,0),
+	M_005600("0x015E0",2,3,5,1,4,0),
+	M_005675("0x0162B",5,3,1,2,4,0),
+	M_005685("0x01635",3,5,1,2,4,0),
+	M_005735("0x01667",5,1,3,2,4,0),
+	M_005755("0x0167B",1,5,3,2,4,0),
+	M_005805("0x016AD",3,1,5,2,4,0),
+	M_005815("0x016B7",1,3,5,2,4,0),
+	M_005885("0x016FD",5,2,1,3,4,0),
+	M_005900("0x0170C",2,5,1,3,4,0),
+	M_005915("0x0171B",5,1,2,3,4,0),
+	M_005935("0x0172F",1,5,2,3,4,0),
+	M_006020("0x01784",2,1,5,3,4,0),
+	M_006025("0x01789",1,2,5,3,4,0),
+	M_006315("0x018AB",3,2,1,5,4,0),
+	M_006320("0x018B0",2,3,1,5,4,0),
+	M_006345("0x018C9",3,1,2,5,4,0),
+	M_006355("0x018D3",1,3,2,5,4,0),
+	M_006380("0x018EC",2,1,3,5,4,0),
+	M_006385("0x018F1",1,2,3,5,4,0),
+	M_006790("0x01A86",4,3,2,1,5,0),
+	M_006795("0x01A8B",3,4,2,1,5,0),
+	M_006820("0x01AA4",4,2,3,1,5,0),
+	M_006830("0x01AAE",2,4,3,1,5,0),
+	M_006855("0x01AC7",3,2,4,1,5,0),
+	M_006860("0x01ACC",2,3,4,1,5,0),
+	M_006970("0x01B3A",4,3,1,2,5,0),
+	M_006975("0x01B3F",3,4,1,2,5,0),
+	M_007030("0x01B76",4,1,3,2,5,0),
+	M_007045("0x01B85",1,4,3,2,5,0),
+	M_007065("0x01B99",3,1,4,2,5,0),
+	M_007075("0x01BA3",1,3,4,2,5,0),
+	M_007180("0x01C0C",4,2,1,3,5,0),
+	M_007190("0x01C16",2,4,1,3,5,0),
+	M_007210("0x01C2A",4,1,2,3,5,0),
+	M_007225("0x01C39",1,4,2,3,5,0),
+	M_007280("0x01C70",2,1,4,3,5,0),
+	M_007285("0x01C75",1,2,4,3,5,0),
+	M_007395("0x01CE3",3,2,1,4,5,0),
+	M_007400("0x01CE8",2,3,1,4,5,0),
+	M_007425("0x01D01",3,1,2,4,5,0),
+	M_007435("0x01D0B",1,3,2,4,5,0),
+	M_007460("0x01D24",2,1,3,4,5,0),
+	M_007465("0x01D29",1,2,3,4,5,0),
+	M_008345("0x02099",5,4,3,2,0,1),
+	M_008350("0x0209E",4,5,3,2,0,1),
+	M_008375("0x020B7",5,3,4,2,0,1),
+	M_008385("0x020C1",3,5,4,2,0,1),
+	M_008410("0x020DA",4,3,5,2,0,1),
+	M_008415("0x020DF",3,4,5,2,0,1),
+	M_008525("0x0214D",5,4,2,3,0,1),
+	M_008530("0x02152",4,5,2,3,0,1),
+	M_008585("0x02189",5,2,4,3,0,1),
+	M_008600("0x02198",2,5,4,3,0,1),
+	M_008620("0x021AC",4,2,5,3,0,1),
+	M_008630("0x021B6",2,4,5,3,0,1),
+	M_008735("0x0221F",5,3,2,4,0,1),
+	M_008745("0x02229",3,5,2,4,0,1),
+	M_008765("0x0223D",5,2,3,4,0,1),
+	M_008780("0x0224C",2,5,3,4,0,1),
+	M_008835("0x02283",3,2,5,4,0,1),
+	M_008840("0x02288",2,3,5,4,0,1),
+	M_008950("0x022F6",4,3,2,5,0,1),
+	M_008955("0x022FB",3,4,2,5,0,1),
+	M_008980("0x02314",4,2,3,5,0,1),
+	M_008990("0x0231E",2,4,3,5,0,1),
+	M_009015("0x02337",3,2,4,5,0,1),
+	M_009020("0x0233C",2,3,4,5,0,1),
+	M_010505("0x02909",5,4,3,0,2,1),
+	M_010510("0x0290E",4,5,3,0,2,1),
+	M_010535("0x02927",5,3,4,0,2,1),
+	M_010545("0x02931",3,5,4,0,2,1),
+	M_010570("0x0294A",4,3,5,0,2,1),
+	M_010575("0x0294F",3,4,5,0,2,1),
+	M_011045("0x02B25",5,4,0,3,2,1),
+	M_011050("0x02B2A",4,5,0,3,2,1),
+	M_011165("0x02B9D",5,0,4,3,2,1),
+	M_011190("0x02BB6",0,5,4,3,2,1),
+	M_011200("0x02BC0",4,0,5,3,2,1),
+	M_011220("0x02BD4",0,4,5,3,2,1),
+	M_011255("0x02BF7",5,3,0,4,2,1),
+	M_011265("0x02C01",3,5,0,4,2,1),
+	M_011345("0x02C51",5,0,3,4,2,1),
+	M_011370("0x02C6A",0,5,3,4,2,1),
+	M_011415("0x02C97",3,0,5,4,2,1),
+	M_011430("0x02CA6",0,3,5,4,2,1),
+	M_011470("0x02CCE",4,3,0,5,2,1),
+	M_011475("0x02CD3",3,4,0,5,2,1),
+	M_011560("0x02D28",4,0,3,5,2,1),
+	M_011580("0x02D3C",0,4,3,5,2,1),
+	M_011595("0x02D4B",3,0,4,5,2,1),
+	M_011610("0x02D5A",0,3,4,5,2,1),
+	M_011765("0x02DF5",5,4,2,0,3,1),
+	M_011770("0x02DFA",4,5,2,0,3,1),
+	M_011825("0x02E31",5,2,4,0,3,1),
+	M_011840("0x02E40",2,5,4,0,3,1),
+	M_011860("0x02E54",4,2,5,0,3,1),
+	M_011870("0x02E5E",2,4,5,0,3,1),
+	M_012125("0x02F5D",5,4,0,2,3,1),
+	M_012130("0x02F62",4,5,0,2,3,1),
+	M_012245("0x02FD5",5,0,4,2,3,1),
+	M_012270("0x02FEE",0,5,4,2,3,1),
+	M_012280("0x02FF8",4,0,5,2,3,1),
+	M_012300("0x0300C",0,4,5,2,3,1),
+	M_012545("0x03101",5,2,0,4,3,1),
+	M_012560("0x03110",2,5,0,4,3,1),
+	M_012605("0x0313D",5,0,2,4,3,1),
+	M_012630("0x03156",0,5,2,4,3,1),
+	M_012710("0x031A6",2,0,5,4,3,1),
+	M_012720("0x031B0",0,2,5,4,3,1),
+	M_012760("0x031D8",4,2,0,5,3,1),
+	M_012770("0x031E2",2,4,0,5,3,1),
+	M_012820("0x03214",4,0,2,5,3,1),
+	M_012840("0x03228",0,4,2,5,3,1),
+	M_012890("0x0325A",2,0,4,5,3,1),
+	M_012900("0x03264",0,2,4,5,3,1),
+	M_013055("0x032FF",5,3,2,0,4,1),
+	M_013065("0x03309",3,5,2,0,4,1),
+	M_013085("0x0331D",5,2,3,0,4,1),
+	M_013100("0x0332C",2,5,3,0,4,1),
+	M_013155("0x03363",3,2,5,0,4,1),
+	M_013160("0x03368",2,3,5,0,4,1),
+	M_013415("0x03467",5,3,0,2,4,1),
+	M_013425("0x03471",3,5,0,2,4,1),
+	M_013505("0x034C1",5,0,3,2,4,1),
+	M_013530("0x034DA",0,5,3,2,4,1),
+	M_013575("0x03507",3,0,5,2,4,1),
+	M_013590("0x03516",0,3,5,2,4,1),
+	M_013625("0x03539",5,2,0,3,4,1),
+	M_013640("0x03548",2,5,0,3,4,1),
+	M_013685("0x03575",5,0,2,3,4,1),
+	M_013710("0x0358E",0,5,2,3,4,1),
+	M_013790("0x035DE",2,0,5,3,4,1),
+	M_013800("0x035E8",0,2,5,3,4,1),
+	M_014055("0x036E7",3,2,0,5,4,1),
+	M_014060("0x036EC",2,3,0,5,4,1),
+	M_014115("0x03723",3,0,2,5,4,1),
+	M_014130("0x03732",0,3,2,5,4,1),
+	M_014150("0x03746",2,0,3,5,4,1),
+	M_014160("0x03750",0,2,3,5,4,1),
+	M_014350("0x0380E",4,3,2,0,5,1),
+	M_014355("0x03813",3,4,2,0,5,1),
+	M_014380("0x0382C",4,2,3,0,5,1),
+	M_014390("0x03836",2,4,3,0,5,1),
+	M_014415("0x0384F",3,2,4,0,5,1),
+	M_014420("0x03854",2,3,4,0,5,1),
+	M_014710("0x03976",4,3,0,2,5,1),
+	M_014715("0x0397B",3,4,0,2,5,1),
+	M_014800("0x039D0",4,0,3,2,5,1),
+	M_014820("0x039E4",0,4,3,2,5,1),
+	M_014835("0x039F3",3,0,4,2,5,1),
+	M_014850("0x03A02",0,3,4,2,5,1),
+	M_014920("0x03A48",4,2,0,3,5,1),
+	M_014930("0x03A52",2,4,0,3,5,1),
+	M_014980("0x03A84",4,0,2,3,5,1),
+	M_015000("0x03A98",0,4,2,3,5,1),
+	M_015050("0x03ACA",2,0,4,3,5,1),
+	M_015060("0x03AD4",0,2,4,3,5,1),
+	M_015135("0x03B1F",3,2,0,4,5,1),
+	M_015140("0x03B24",2,3,0,4,5,1),
+	M_015195("0x03B5B",3,0,2,4,5,1),
+	M_015210("0x03B6A",0,3,2,4,5,1),
+	M_015230("0x03B7E",2,0,3,4,5,1),
+	M_015240("0x03B88",0,2,3,4,5,1),
+	M_015905("0x03E21",5,4,3,1,0,2),
+	M_015910("0x03E26",4,5,3,1,0,2),
+	M_015935("0x03E3F",5,3,4,1,0,2),
+	M_015945("0x03E49",3,5,4,1,0,2),
+	M_015970("0x03E62",4,3,5,1,0,2),
+	M_015975("0x03E67",3,4,5,1,0,2),
+	M_016265("0x03F89",5,4,1,3,0,2),
+	M_016270("0x03F8E",4,5,1,3,0,2),
+	M_016355("0x03FE3",5,1,4,3,0,2),
+	M_016375("0x03FF7",1,5,4,3,0,2),
+	M_016390("0x04006",4,1,5,3,0,2),
+	M_016405("0x04015",1,4,5,3,0,2),
+	M_016475("0x0405B",5,3,1,4,0,2),
+	M_016485("0x04065",3,5,1,4,0,2),
+	M_016535("0x04097",5,1,3,4,0,2),
+	M_016555("0x040AB",1,5,3,4,0,2),
+	M_016605("0x040DD",3,1,5,4,0,2),
+	M_016615("0x040E7",1,3,5,4,0,2),
+	M_016690("0x04132",4,3,1,5,0,2),
+	M_016695("0x04137",3,4,1,5,0,2),
+	M_016750("0x0416E",4,1,3,5,0,2),
+	M_016765("0x0417D",1,4,3,5,0,2),
+	M_016785("0x04191",3,1,4,5,0,2),
+	M_016795("0x0419B",1,3,4,5,0,2),
+	M_016985("0x04259",5,4,3,0,1,2),
+	M_016990("0x0425E",4,5,3,0,1,2),
+	M_017015("0x04277",5,3,4,0,1,2),
+	M_017025("0x04281",3,5,4,0,1,2),
+	M_017050("0x0429A",4,3,5,0,1,2),
+	M_017055("0x0429F",3,4,5,0,1,2),
+	M_017525("0x04475",5,4,0,3,1,2),
+	M_017530("0x0447A",4,5,0,3,1,2),
+	M_017645("0x044ED",5,0,4,3,1,2),
+	M_017670("0x04506",0,5,4,3,1,2),
+	M_017680("0x04510",4,0,5,3,1,2),
+	M_017700("0x04524",0,4,5,3,1,2),
+	M_017735("0x04547",5,3,0,4,1,2),
+	M_017745("0x04551",3,5,0,4,1,2),
+	M_017825("0x045A1",5,0,3,4,1,2),
+	M_017850("0x045BA",0,5,3,4,1,2),
+	M_017895("0x045E7",3,0,5,4,1,2),
+	M_017910("0x045F6",0,3,5,4,1,2),
+	M_017950("0x0461E",4,3,0,5,1,2),
+	M_017955("0x04623",3,4,0,5,1,2),
+	M_018040("0x04678",4,0,3,5,1,2),
+	M_018060("0x0468C",0,4,3,5,1,2),
+	M_018075("0x0469B",3,0,4,5,1,2),
+	M_018090("0x046AA",0,3,4,5,1,2),
+	M_019505("0x04C31",5,4,1,0,3,2),
+	M_019510("0x04C36",4,5,1,0,3,2),
+	M_019595("0x04C8B",5,1,4,0,3,2),
+	M_019615("0x04C9F",1,5,4,0,3,2),
+	M_019630("0x04CAE",4,1,5,0,3,2),
+	M_019645("0x04CBD",1,4,5,0,3,2),
+	M_019685("0x04CE5",5,4,0,1,3,2),
+	M_019690("0x04CEA",4,5,0,1,3,2),
+	M_019805("0x04D5D",5,0,4,1,3,2),
+	M_019830("0x04D76",0,5,4,1,3,2),
+	M_019840("0x04D80",4,0,5,1,3,2),
+	M_019860("0x04D94",0,4,5,1,3,2),
+	M_020315("0x04F5B",5,1,0,4,3,2),
+	M_020335("0x04F6F",1,5,0,4,3,2),
+	M_020345("0x04F79",5,0,1,4,3,2),
+	M_020370("0x04F92",0,5,1,4,3,2),
+	M_020485("0x05005",1,0,5,4,3,2),
+	M_020490("0x0500A",0,1,5,4,3,2),
+	M_020530("0x05032",4,1,0,5,3,2),
+	M_020545("0x05041",1,4,0,5,3,2),
+	M_020560("0x05050",4,0,1,5,3,2),
+	M_020580("0x05064",0,4,1,5,3,2),
+	M_020665("0x050B9",1,0,4,5,3,2),
+	M_020670("0x050BE",0,1,4,5,3,2),
+	M_020795("0x0513B",5,3,1,0,4,2),
+	M_020805("0x05145",3,5,1,0,4,2),
+	M_020855("0x05177",5,1,3,0,4,2),
+	M_020875("0x0518B",1,5,3,0,4,2),
+	M_020925("0x051BD",3,1,5,0,4,2),
+	M_020935("0x051C7",1,3,5,0,4,2),
+	M_020975("0x051EF",5,3,0,1,4,2),
+	M_020985("0x051F9",3,5,0,1,4,2),
+	M_021065("0x05249",5,0,3,1,4,2),
+	M_021090("0x05262",0,5,3,1,4,2),
+	M_021135("0x0528F",3,0,5,1,4,2),
+	M_021150("0x0529E",0,3,5,1,4,2),
+	M_021395("0x05393",5,1,0,3,4,2),
+	M_021415("0x053A7",1,5,0,3,4,2),
+	M_021425("0x053B1",5,0,1,3,4,2),
+	M_021450("0x053CA",0,5,1,3,4,2),
+	M_021565("0x0543D",1,0,5,3,4,2),
+	M_021570("0x05442",0,1,5,3,4,2),
+	M_021825("0x05541",3,1,0,5,4,2),
+	M_021835("0x0554B",1,3,0,5,4,2),
+	M_021855("0x0555F",3,0,1,5,4,2),
+	M_021870("0x0556E",0,3,1,5,4,2),
+	M_021925("0x055A5",1,0,3,5,4,2),
+	M_021930("0x055AA",0,1,3,5,4,2),
+	M_022090("0x0564A",4,3,1,0,5,2),
+	M_022095("0x0564F",3,4,1,0,5,2),
+	M_022150("0x05686",4,1,3,0,5,2),
+	M_022165("0x05695",1,4,3,0,5,2),
+	M_022185("0x056A9",3,1,4,0,5,2),
+	M_022195("0x056B3",1,3,4,0,5,2),
+	M_022270("0x056FE",4,3,0,1,5,2),
+	M_022275("0x05703",3,4,0,1,5,2),
+	M_022360("0x05758",4,0,3,1,5,2),
+	M_022380("0x0576C",0,4,3,1,5,2),
+	M_022395("0x0577B",3,0,4,1,5,2),
+	M_022410("0x0578A",0,3,4,1,5,2),
+	M_022690("0x058A2",4,1,0,3,5,2),
+	M_022705("0x058B1",1,4,0,3,5,2),
+	M_022720("0x058C0",4,0,1,3,5,2),
+	M_022740("0x058D4",0,4,1,3,5,2),
+	M_022825("0x05929",1,0,4,3,5,2),
+	M_022830("0x0592E",0,1,4,3,5,2),
+	M_022905("0x05979",3,1,0,4,5,2),
+	M_022915("0x05983",1,3,0,4,5,2),
+	M_022935("0x05997",3,0,1,4,5,2),
+	M_022950("0x059A6",0,3,1,4,5,2),
+	M_023005("0x059DD",1,0,3,4,5,2),
+	M_023010("0x059E2",0,1,3,4,5,2),
+	M_023645("0x05C5D",5,4,2,1,0,3),
+	M_023650("0x05C62",4,5,2,1,0,3),
+	M_023705("0x05C99",5,2,4,1,0,3),
+	M_023720("0x05CA8",2,5,4,1,0,3),
+	M_023740("0x05CBC",4,2,5,1,0,3),
+	M_023750("0x05CC6",2,4,5,1,0,3),
+	M_023825("0x05D11",5,4,1,2,0,3),
+	M_023830("0x05D16",4,5,1,2,0,3),
+	M_023915("0x05D6B",5,1,4,2,0,3),
+	M_023935("0x05D7F",1,5,4,2,0,3),
+	M_023950("0x05D8E",4,1,5,2,0,3),
+	M_023965("0x05D9D",1,4,5,2,0,3),
+	M_024245("0x05EB5",5,2,1,4,0,3),
+	M_024260("0x05EC4",2,5,1,4,0,3),
+	M_024275("0x05ED3",5,1,2,4,0,3),
+	M_024295("0x05EE7",1,5,2,4,0,3),
+	M_024380("0x05F3C",2,1,5,4,0,3),
+	M_024385("0x05F41",1,2,5,4,0,3),
+	M_024460("0x05F8C",4,2,1,5,0,3),
+	M_024470("0x05F96",2,4,1,5,0,3),
+	M_024490("0x05FAA",4,1,2,5,0,3),
+	M_024505("0x05FB9",1,4,2,5,0,3),
+	M_024560("0x05FF0",2,1,4,5,0,3),
+	M_024565("0x05FF5",1,2,4,5,0,3),
+	M_024725("0x06095",5,4,2,0,1,3),
+	M_024730("0x0609A",4,5,2,0,1,3),
+	M_024785("0x060D1",5,2,4,0,1,3),
+	M_024800("0x060E0",2,5,4,0,1,3),
+	M_024820("0x060F4",4,2,5,0,1,3),
+	M_024830("0x060FE",2,4,5,0,1,3),
+	M_025085("0x061FD",5,4,0,2,1,3),
+	M_025090("0x06202",4,5,0,2,1,3),
+	M_025205("0x06275",5,0,4,2,1,3),
+	M_025230("0x0628E",0,5,4,2,1,3),
+	M_025240("0x06298",4,0,5,2,1,3),
+	M_025260("0x062AC",0,4,5,2,1,3),
+	M_025505("0x063A1",5,2,0,4,1,3),
+	M_025520("0x063B0",2,5,0,4,1,3),
+	M_025565("0x063DD",5,0,2,4,1,3),
+	M_025590("0x063F6",0,5,2,4,1,3),
+	M_025670("0x06446",2,0,5,4,1,3),
+	M_025680("0x06450",0,2,5,4,1,3),
+	M_025720("0x06478",4,2,0,5,1,3),
+	M_025730("0x06482",2,4,0,5,1,3),
+	M_025780("0x064B4",4,0,2,5,1,3),
+	M_025800("0x064C8",0,4,2,5,1,3),
+	M_025850("0x064FA",2,0,4,5,1,3),
+	M_025860("0x06504",0,2,4,5,1,3),
+	M_025985("0x06581",5,4,1,0,2,3),
+	M_025990("0x06586",4,5,1,0,2,3),
+	M_026075("0x065DB",5,1,4,0,2,3),
+	M_026095("0x065EF",1,5,4,0,2,3),
+	M_026110("0x065FE",4,1,5,0,2,3),
+	M_026125("0x0660D",1,4,5,0,2,3),
+	M_026165("0x06635",5,4,0,1,2,3),
+	M_026170("0x0663A",4,5,0,1,2,3),
+	M_026285("0x066AD",5,0,4,1,2,3),
+	M_026310("0x066C6",0,5,4,1,2,3),
+	M_026320("0x066D0",4,0,5,1,2,3),
+	M_026340("0x066E4",0,4,5,1,2,3),
+	M_026795("0x068AB",5,1,0,4,2,3),
+	M_026815("0x068BF",1,5,0,4,2,3),
+	M_026825("0x068C9",5,0,1,4,2,3),
+	M_026850("0x068E2",0,5,1,4,2,3),
+	M_026965("0x06955",1,0,5,4,2,3),
+	M_026970("0x0695A",0,1,5,4,2,3),
+	M_027010("0x06982",4,1,0,5,2,3),
+	M_027025("0x06991",1,4,0,5,2,3),
+	M_027040("0x069A0",4,0,1,5,2,3),
+	M_027060("0x069B4",0,4,1,5,2,3),
+	M_027145("0x06A09",1,0,4,5,2,3),
+	M_027150("0x06A0E",0,1,4,5,2,3),
+	M_028565("0x06F95",5,2,1,0,4,3),
+	M_028580("0x06FA4",2,5,1,0,4,3),
+	M_028595("0x06FB3",5,1,2,0,4,3),
+	M_028615("0x06FC7",1,5,2,0,4,3),
+	M_028700("0x0701C",2,1,5,0,4,3),
+	M_028705("0x07021",1,2,5,0,4,3),
+	M_028745("0x07049",5,2,0,1,4,3),
+	M_028760("0x07058",2,5,0,1,4,3),
+	M_028805("0x07085",5,0,2,1,4,3),
+	M_028830("0x0709E",0,5,2,1,4,3),
+	M_028910("0x070EE",2,0,5,1,4,3),
+	M_028920("0x070F8",0,2,5,1,4,3),
+	M_028955("0x0711B",5,1,0,2,4,3),
+	M_028975("0x0712F",1,5,0,2,4,3),
+	M_028985("0x07139",5,0,1,2,4,3),
+	M_029010("0x07152",0,5,1,2,4,3),
+	M_029125("0x071C5",1,0,5,2,4,3),
+	M_029130("0x071CA",0,1,5,2,4,3),
+	M_029600("0x073A0",2,1,0,5,4,3),
+	M_029605("0x073A5",1,2,0,5,4,3),
+	M_029630("0x073BE",2,0,1,5,4,3),
+	M_029640("0x073C8",0,2,1,5,4,3),
+	M_029665("0x073E1",1,0,2,5,4,3),
+	M_029670("0x073E6",0,1,2,5,4,3),
+	M_029860("0x074A4",4,2,1,0,5,3),
+	M_029870("0x074AE",2,4,1,0,5,3),
+	M_029890("0x074C2",4,1,2,0,5,3),
+	M_029905("0x074D1",1,4,2,0,5,3),
+	M_029960("0x07508",2,1,4,0,5,3),
+	M_029965("0x0750D",1,2,4,0,5,3),
+	M_030040("0x07558",4,2,0,1,5,3),
+	M_030050("0x07562",2,4,0,1,5,3),
+	M_030100("0x07594",4,0,2,1,5,3),
+	M_030120("0x075A8",0,4,2,1,5,3),
+	M_030170("0x075DA",2,0,4,1,5,3),
+	M_030180("0x075E4",0,2,4,1,5,3),
+	M_030250("0x0762A",4,1,0,2,5,3),
+	M_030265("0x07639",1,4,0,2,5,3),
+	M_030280("0x07648",4,0,1,2,5,3),
+	M_030300("0x0765C",0,4,1,2,5,3),
+	M_030385("0x076B1",1,0,4,2,5,3),
+	M_030390("0x076B6",0,1,4,2,5,3),
+	M_030680("0x077D8",2,1,0,4,5,3),
+	M_030685("0x077DD",1,2,0,4,5,3),
+	M_030710("0x077F6",2,0,1,4,5,3),
+	M_030720("0x07800",0,2,1,4,5,3),
+	M_030745("0x07819",1,0,2,4,5,3),
+	M_030750("0x0781E",0,1,2,4,5,3),
+	M_031415("0x07AB7",5,3,2,1,0,4),
+	M_031425("0x07AC1",3,5,2,1,0,4),
+	M_031445("0x07AD5",5,2,3,1,0,4),
+	M_031460("0x07AE4",2,5,3,1,0,4),
+	M_031515("0x07B1B",3,2,5,1,0,4),
+	M_031520("0x07B20",2,3,5,1,0,4),
+	M_031595("0x07B6B",5,3,1,2,0,4),
+	M_031605("0x07B75",3,5,1,2,0,4),
+	M_031655("0x07BA7",5,1,3,2,0,4),
+	M_031675("0x07BBB",1,5,3,2,0,4),
+	M_031725("0x07BED",3,1,5,2,0,4),
+	M_031735("0x07BF7",1,3,5,2,0,4),
+	M_031805("0x07C3D",5,2,1,3,0,4),
+	M_031820("0x07C4C",2,5,1,3,0,4),
+	M_031835("0x07C5B",5,1,2,3,0,4),
+	M_031855("0x07C6F",1,5,2,3,0,4),
+	M_031940("0x07CC4",2,1,5,3,0,4),
+	M_031945("0x07CC9",1,2,5,3,0,4),
+	M_032235("0x07DEB",3,2,1,5,0,4),
+	M_032240("0x07DF0",2,3,1,5,0,4),
+	M_032265("0x07E09",3,1,2,5,0,4),
+	M_032275("0x07E13",1,3,2,5,0,4),
+	M_032300("0x07E2C",2,1,3,5,0,4),
+	M_032305("0x07E31",1,2,3,5,0,4),
+	M_032495("0x07EEF",5,3,2,0,1,4),
+	M_032505("0x07EF9",3,5,2,0,1,4),
+	M_032525("0x07F0D",5,2,3,0,1,4),
+	M_032540("0x07F1C",2,5,3,0,1,4),
+	M_032595("0x07F53",3,2,5,0,1,4),
+	M_032600("0x07F58",2,3,5,0,1,4),
+	M_032855("0x08057",5,3,0,2,1,4),
+	M_032865("0x08061",3,5,0,2,1,4),
+	M_032945("0x080B1",5,0,3,2,1,4),
+	M_032970("0x080CA",0,5,3,2,1,4),
+	M_033015("0x080F7",3,0,5,2,1,4),
+	M_033030("0x08106",0,3,5,2,1,4),
+	M_033065("0x08129",5,2,0,3,1,4),
+	M_033080("0x08138",2,5,0,3,1,4),
+	M_033125("0x08165",5,0,2,3,1,4),
+	M_033150("0x0817E",0,5,2,3,1,4),
+	M_033230("0x081CE",2,0,5,3,1,4),
+	M_033240("0x081D8",0,2,5,3,1,4),
+	M_033495("0x082D7",3,2,0,5,1,4),
+	M_033500("0x082DC",2,3,0,5,1,4),
+	M_033555("0x08313",3,0,2,5,1,4),
+	M_033570("0x08322",0,3,2,5,1,4),
+	M_033590("0x08336",2,0,3,5,1,4),
+	M_033600("0x08340",0,2,3,5,1,4),
+	M_033755("0x083DB",5,3,1,0,2,4),
+	M_033765("0x083E5",3,5,1,0,2,4),
+	M_033815("0x08417",5,1,3,0,2,4),
+	M_033835("0x0842B",1,5,3,0,2,4),
+	M_033885("0x0845D",3,1,5,0,2,4),
+	M_033895("0x08467",1,3,5,0,2,4),
+	M_033935("0x0848F",5,3,0,1,2,4),
+	M_033945("0x08499",3,5,0,1,2,4),
+	M_034025("0x084E9",5,0,3,1,2,4),
+	M_034050("0x08502",0,5,3,1,2,4),
+	M_034095("0x0852F",3,0,5,1,2,4),
+	M_034110("0x0853E",0,3,5,1,2,4),
+	M_034355("0x08633",5,1,0,3,2,4),
+	M_034375("0x08647",1,5,0,3,2,4),
+	M_034385("0x08651",5,0,1,3,2,4),
+	M_034410("0x0866A",0,5,1,3,2,4),
+	M_034525("0x086DD",1,0,5,3,2,4),
+	M_034530("0x086E2",0,1,5,3,2,4),
+	M_034785("0x087E1",3,1,0,5,2,4),
+	M_034795("0x087EB",1,3,0,5,2,4),
+	M_034815("0x087FF",3,0,1,5,2,4),
+	M_034830("0x0880E",0,3,1,5,2,4),
+	M_034885("0x08845",1,0,3,5,2,4),
+	M_034890("0x0884A",0,1,3,5,2,4),
+	M_035045("0x088E5",5,2,1,0,3,4),
+	M_035060("0x088F4",2,5,1,0,3,4),
+	M_035075("0x08903",5,1,2,0,3,4),
+	M_035095("0x08917",1,5,2,0,3,4),
+	M_035180("0x0896C",2,1,5,0,3,4),
+	M_035185("0x08971",1,2,5,0,3,4),
+	M_035225("0x08999",5,2,0,1,3,4),
+	M_035240("0x089A8",2,5,0,1,3,4),
+	M_035285("0x089D5",5,0,2,1,3,4),
+	M_035310("0x089EE",0,5,2,1,3,4),
+	M_035390("0x08A3E",2,0,5,1,3,4),
+	M_035400("0x08A48",0,2,5,1,3,4),
+	M_035435("0x08A6B",5,1,0,2,3,4),
+	M_035455("0x08A7F",1,5,0,2,3,4),
+	M_035465("0x08A89",5,0,1,2,3,4),
+	M_035490("0x08AA2",0,5,1,2,3,4),
+	M_035605("0x08B15",1,0,5,2,3,4),
+	M_035610("0x08B1A",0,1,5,2,3,4),
+	M_036080("0x08CF0",2,1,0,5,3,4),
+	M_036085("0x08CF5",1,2,0,5,3,4),
+	M_036110("0x08D0E",2,0,1,5,3,4),
+	M_036120("0x08D18",0,2,1,5,3,4),
+	M_036145("0x08D31",1,0,2,5,3,4),
+	M_036150("0x08D36",0,1,2,5,3,4),
+	M_037635("0x09303",3,2,1,0,5,4),
+	M_037640("0x09308",2,3,1,0,5,4),
+	M_037665("0x09321",3,1,2,0,5,4),
+	M_037675("0x0932B",1,3,2,0,5,4),
+	M_037700("0x09344",2,1,3,0,5,4),
+	M_037705("0x09349",1,2,3,0,5,4),
+	M_037815("0x093B7",3,2,0,1,5,4),
+	M_037820("0x093BC",2,3,0,1,5,4),
+	M_037875("0x093F3",3,0,2,1,5,4),
+	M_037890("0x09402",0,3,2,1,5,4),
+	M_037910("0x09416",2,0,3,1,5,4),
+	M_037920("0x09420",0,2,3,1,5,4),
+	M_038025("0x09489",3,1,0,2,5,4),
+	M_038035("0x09493",1,3,0,2,5,4),
+	M_038055("0x094A7",3,0,1,2,5,4),
+	M_038070("0x094B6",0,3,1,2,5,4),
+	M_038125("0x094ED",1,0,3,2,5,4),
+	M_038130("0x094F2",0,1,3,2,5,4),
+	M_038240("0x09560",2,1,0,3,5,4),
+	M_038245("0x09565",1,2,0,3,5,4),
+	M_038270("0x0957E",2,0,1,3,5,4),
+	M_038280("0x09588",0,2,1,3,5,4),
+	M_038305("0x095A1",1,0,2,3,5,4),
+	M_038310("0x095A6",0,1,2,3,5,4),
+	M_039190("0x09916",4,3,2,1,0,5),
+	M_039195("0x0991B",3,4,2,1,0,5),
+	M_039220("0x09934",4,2,3,1,0,5),
+	M_039230("0x0993E",2,4,3,1,0,5),
+	M_039255("0x09957",3,2,4,1,0,5),
+	M_039260("0x0995C",2,3,4,1,0,5),
+	M_039370("0x099CA",4,3,1,2,0,5),
+	M_039375("0x099CF",3,4,1,2,0,5),
+	M_039430("0x09A06",4,1,3,2,0,5),
+	M_039445("0x09A15",1,4,3,2,0,5),
+	M_039465("0x09A29",3,1,4,2,0,5),
+	M_039475("0x09A33",1,3,4,2,0,5),
+	M_039580("0x09A9C",4,2,1,3,0,5),
+	M_039590("0x09AA6",2,4,1,3,0,5),
+	M_039610("0x09ABA",4,1,2,3,0,5),
+	M_039625("0x09AC9",1,4,2,3,0,5),
+	M_039680("0x09B00",2,1,4,3,0,5),
+	M_039685("0x09B05",1,2,4,3,0,5),
+	M_039795("0x09B73",3,2,1,4,0,5),
+	M_039800("0x09B78",2,3,1,4,0,5),
+	M_039825("0x09B91",3,1,2,4,0,5),
+	M_039835("0x09B9B",1,3,2,4,0,5),
+	M_039860("0x09BB4",2,1,3,4,0,5),
+	M_039865("0x09BB9",1,2,3,4,0,5),
+	M_040270("0x09D4E",4,3,2,0,1,5),
+	M_040275("0x09D53",3,4,2,0,1,5),
+	M_040300("0x09D6C",4,2,3,0,1,5),
+	M_040310("0x09D76",2,4,3,0,1,5),
+	M_040335("0x09D8F",3,2,4,0,1,5),
+	M_040340("0x09D94",2,3,4,0,1,5),
+	M_040630("0x09EB6",4,3,0,2,1,5),
+	M_040635("0x09EBB",3,4,0,2,1,5),
+	M_040720("0x09F10",4,0,3,2,1,5),
+	M_040740("0x09F24",0,4,3,2,1,5),
+	M_040755("0x09F33",3,0,4,2,1,5),
+	M_040770("0x09F42",0,3,4,2,1,5),
+	M_040840("0x09F88",4,2,0,3,1,5),
+	M_040850("0x09F92",2,4,0,3,1,5),
+	M_040900("0x09FC4",4,0,2,3,1,5),
+	M_040920("0x09FD8",0,4,2,3,1,5),
+	M_040970("0x0A00A",2,0,4,3,1,5),
+	M_040980("0x0A014",0,2,4,3,1,5),
+	M_041055("0x0A05F",3,2,0,4,1,5),
+	M_041060("0x0A064",2,3,0,4,1,5),
+	M_041115("0x0A09B",3,0,2,4,1,5),
+	M_041130("0x0A0AA",0,3,2,4,1,5),
+	M_041150("0x0A0BE",2,0,3,4,1,5),
+	M_041160("0x0A0C8",0,2,3,4,1,5),
+	M_041530("0x0A23A",4,3,1,0,2,5),
+	M_041535("0x0A23F",3,4,1,0,2,5),
+	M_041590("0x0A276",4,1,3,0,2,5),
+	M_041605("0x0A285",1,4,3,0,2,5),
+	M_041625("0x0A299",3,1,4,0,2,5),
+	M_041635("0x0A2A3",1,3,4,0,2,5),
+	M_041710("0x0A2EE",4,3,0,1,2,5),
+	M_041715("0x0A2F3",3,4,0,1,2,5),
+	M_041800("0x0A348",4,0,3,1,2,5),
+	M_041820("0x0A35C",0,4,3,1,2,5),
+	M_041835("0x0A36B",3,0,4,1,2,5),
+	M_041850("0x0A37A",0,3,4,1,2,5),
+	M_042130("0x0A492",4,1,0,3,2,5),
+	M_042145("0x0A4A1",1,4,0,3,2,5),
+	M_042160("0x0A4B0",4,0,1,3,2,5),
+	M_042180("0x0A4C4",0,4,1,3,2,5),
+	M_042265("0x0A519",1,0,4,3,2,5),
+	M_042270("0x0A51E",0,1,4,3,2,5),
+	M_042345("0x0A569",3,1,0,4,2,5),
+	M_042355("0x0A573",1,3,0,4,2,5),
+	M_042375("0x0A587",3,0,1,4,2,5),
+	M_042390("0x0A596",0,3,1,4,2,5),
+	M_042445("0x0A5CD",1,0,3,4,2,5),
+	M_042450("0x0A5D2",0,1,3,4,2,5),
+	M_042820("0x0A744",4,2,1,0,3,5),
+	M_042830("0x0A74E",2,4,1,0,3,5),
+	M_042850("0x0A762",4,1,2,0,3,5),
+	M_042865("0x0A771",1,4,2,0,3,5),
+	M_042920("0x0A7A8",2,1,4,0,3,5),
+	M_042925("0x0A7AD",1,2,4,0,3,5),
+	M_043000("0x0A7F8",4,2,0,1,3,5),
+	M_043010("0x0A802",2,4,0,1,3,5),
+	M_043060("0x0A834",4,0,2,1,3,5),
+	M_043080("0x0A848",0,4,2,1,3,5),
+	M_043130("0x0A87A",2,0,4,1,3,5),
+	M_043140("0x0A884",0,2,4,1,3,5),
+	M_043210("0x0A8CA",4,1,0,2,3,5),
+	M_043225("0x0A8D9",1,4,0,2,3,5),
+	M_043240("0x0A8E8",4,0,1,2,3,5),
+	M_043260("0x0A8FC",0,4,1,2,3,5),
+	M_043345("0x0A951",1,0,4,2,3,5),
+	M_043350("0x0A956",0,1,4,2,3,5),
+	M_043640("0x0AA78",2,1,0,4,3,5),
+	M_043645("0x0AA7D",1,2,0,4,3,5),
+	M_043670("0x0AA96",2,0,1,4,3,5),
+	M_043680("0x0AAA0",0,2,1,4,3,5),
+	M_043705("0x0AAB9",1,0,2,4,3,5),
+	M_043710("0x0AABE",0,1,2,4,3,5),
+	M_044115("0x0AC53",3,2,1,0,4,5),
+	M_044120("0x0AC58",2,3,1,0,4,5),
+	M_044145("0x0AC71",3,1,2,0,4,5),
+	M_044155("0x0AC7B",1,3,2,0,4,5),
+	M_044180("0x0AC94",2,1,3,0,4,5),
+	M_044185("0x0AC99",1,2,3,0,4,5),
+	M_044295("0x0AD07",3,2,0,1,4,5),
+	M_044300("0x0AD0C",2,3,0,1,4,5),
+	M_044355("0x0AD43",3,0,2,1,4,5),
+	M_044370("0x0AD52",0,3,2,1,4,5),
+	M_044390("0x0AD66",2,0,3,1,4,5),
+	M_044400("0x0AD70",0,2,3,1,4,5),
+	M_044505("0x0ADD9",3,1,0,2,4,5),
+	M_044515("0x0ADE3",1,3,0,2,4,5),
+	M_044535("0x0ADF7",3,0,1,2,4,5),
+	M_044550("0x0AE06",0,3,1,2,4,5),
+	M_044605("0x0AE3D",1,0,3,2,4,5),
+	M_044610("0x0AE42",0,1,3,2,4,5),
+	M_044720("0x0AEB0",2,1,0,3,4,5),
+	M_044725("0x0AEB5",1,2,0,3,4,5),
+	M_044750("0x0AECE",2,0,1,3,4,5),
+	M_044760("0x0AED8",0,2,1,3,4,5),
+	M_044785("0x0AEF1",1,0,2,3,4,5),
+	M_044790("0x0AEF6",0,1,2,3,4,5),
+	;
+	
+	public final static M06MatrixSeximal STATIC = M06MatrixSeximal.M_001865;
+	public final static M06MatrixSeximal TAIL = STATIC.rȧñkNaarLaatste();
+	
+	private M06MatrixSeximal(String dialTone, int...args) {
+		BãßBȍőnNumberMatrixʸᴰ.Ꝑŕḯṿª₮ḕ.יהוהʸᴰ(this, dialTone, args);
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixFactory.java

@@ -0,0 +1,192 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import java.text.DecimalFormat;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.Bãß;
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytsFlüstern注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ.ArrayListᴿᵂ;
+import ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ.Listᴿᵈ;
+import ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ.Listᵂʳ;
+import ᒢᐩᐩ.ᔿᐤᒄʸ.ᣔᒃᣔᒼᓑᔆ.BãßBȍőnAbacusInstanceMBeanʸᴰ;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@BãßBȍőnDuytsFlüstern注(purpose = "Dynamic acces to the number matrix")
+public enum NumberMatrixFactory implements BãßBȍőnAbacusInstanceMBeanʸᴰ<NumberMatrixFactory> {
+	INSTANCE;
+	
+	private final Map<Integer, NumberMatrixSet> theMatrix;
+	private static final int[] FILM_STUDIO_RECODINGS = new int[] {2,3,4,5,6};
+	
+	private NumberMatrixFactory() {
+		Bãß.石棺ʸᴰ.أَكْبَرײꣻײالله.𓂀ױןייזדזיודזיןןזזזןױ𓉢(this);
+		theMatrix = Collections.synchronizedMap(new HashMap<>());
+	}
+	
+	public int[] opgenomenFilmNummers() {
+		return FILM_STUDIO_RECODINGS;
+	}
+	
+	public NumberMatrixSet geefFilmSet(int dimension) {
+		NumberMatrixSet result = theMatrix.get(dimension);
+		if (result == null) {
+			result = buildMatrixSet(dimension);
+			theMatrix.put(dimension, result);
+		}
+		return result;
+	}
+	
+	private NumberMatrixSet buildMatrixSet(int dimension) {
+		if (dimension < 2) {
+			throw new IllegalArgumentException("Dimension smaller than 2 are not supported");
+		}
+		if (dimension == 2) {
+			return new NumberMatrixSetEnum(M02MatrixBinary.STATIC.teŀráàmWaardes());
+		} else if (dimension == 3) {
+			return new NumberMatrixSetEnum(M03MatrixTrit.STATIC.teŀráàmWaardes());
+		} else if (dimension == 4) {
+			return new NumberMatrixSetEnum(M04MatrixQuad.STATIC.teŀráàmWaardes());
+		} else if (dimension == 5) {
+			return new NumberMatrixSetEnum(M05MatrixPental.STATIC.teŀráàmWaardes());
+		} else if (dimension == 6) {
+			return new NumberMatrixSetEnum(M06MatrixSeximal.STATIC.teŀráàmWaardes());
+		}
+		return buildMatrixSetSpaceX(dimension);
+	}
+	
+	static final class NumberMatrixSetEnum implements NumberMatrixSet {
+		
+		private final Listᴿᵈ<BãßBȍőnNumberMatrixʸᴰ<?>> values;
+		
+		@SuppressWarnings("unchecked")
+		protected <T extends BãßBȍőnNumberMatrixʸᴰ<T>> NumberMatrixSetEnum(Listᴿᵈ<T> values) {
+			this.values = (Listᴿᵈ<BãßBȍőnNumberMatrixʸᴰ<?>>) values;
+		}
+		
+		@Override
+		public int geefDimensie() {
+			return values.getᴿᵈ(0).teŀráàmMatrixDimensie();
+		}
+		
+		@SuppressWarnings("unchecked")
+		@Override
+		public <T extends BãßBȍőnNumberMatrixʸᴰ<T>> Listᴿᵈ<T> waardes() {
+			return (Listᴿᵈ<T>) values;
+		}
+	}
+	
+	// dimension: 7  size:   5040
+	// dimension: 8  size:  40320
+	// dimension: 9  size: 362880
+	// dimension: 10 size: 779280
+	private NumberMatrixSet buildMatrixSetSpaceX(int dimension) {
+		if (dimension < 2) {
+			throw new IllegalArgumentException("dimension is to small");
+		}
+		NumberMatrixSetDimension result = new NumberMatrixSetDimension(dimension);
+		// X number that count up
+		int size = dimension;
+		int cnt = 0;
+		int len = (int)Math.pow(size, size);
+		StringBuilder digi = new StringBuilder();
+		for (int i=0;i<size;i++) {
+			digi.append("0");
+		}
+		DecimalFormat digiFormat = new DecimalFormat(digi.toString());
+		for (int i=0;i<len;i++) {
+			String num = Integer.toUnsignedString(cnt, size);
+			StringBuilder buf = new StringBuilder();
+			for (int x=size-num.length();x>0;x--) {
+				buf.append("0");
+			}
+			buf.append(num);
+			String ii = buf.toString();
+			Set<Character> set = new HashSet<>();
+			for (int y=size-1;y>=0;y--) {
+				char c = ii.charAt(y);
+				set.add(c);
+			}
+			if (set.size() == size) {
+				String cntHex = Integer.toHexString(cnt).toUpperCase();
+				if (cntHex.length() < size-1) {
+					cntHex = "0"+cntHex;
+				}
+				if (cntHex.length() < size-1) {
+					cntHex = "0"+cntHex;
+				}
+				String numberStr = digiFormat.format(i);
+				String name = "M_"+numberStr;
+				int[] args = new int[size];
+				for (int y=size-1;y>=0;y--) {
+					char c = ii.charAt(y);
+					args[y] = c - '0';
+				}
+				result.createAbacus(cnt, name, "0x"+cntHex, args);
+			}
+			cnt++;
+		}
+		return result;
+	}
+	
+	static final class NumberMatrixSetDimension implements NumberMatrixSet {
+		private final int dimension;
+		private Listᵂʳ<Abacus> values = new ArrayListᴿᵂ<>();
+		
+		protected NumberMatrixSetDimension(int dimension) {
+			this.dimension = dimension;
+		}
+		
+		protected void createAbacus(int itemOrdinal, String itemName, String dialTone, int...args) {
+			values.addᵂʳ(new Abacus(itemOrdinal, itemName, dialTone, args));
+		}
+		
+		@Override
+		public int geefDimensie() {
+			return dimension;
+		}
+		
+		@SuppressWarnings("unchecked")
+		@Override
+		public <T extends BãßBȍőnNumberMatrixʸᴰ<T>> Listᴿᵈ<T> waardes() {
+			return (Listᴿᵈ<T>) values;
+		}
+		
+		@BãßBȍőnNumberMatrix注(dimension = -1)
+		public class Abacus implements BãßBȍőnNumberMatrixʸᴰ<Abacus> {
+			
+			private final int itemOrdinal;
+			private final String itemName;
+			
+			private Abacus(int itemOrdinal, String itemName, String dialTone, int...args) {
+				this.itemOrdinal = itemOrdinal;
+				this.itemName = itemName;
+				BãßBȍőnNumberMatrixʸᴰ.Ꝑŕḯṿª₮ḕ.יהוהʸᴰ(this, dialTone, args);
+			}
+			
+			@Override
+			public int ordinal() {
+				return itemOrdinal;
+			}
+			
+			@Override
+			public String name() {
+				return itemName;
+			}
+			
+			@Override
+			public Listᴿᵈ<Abacus> teŀráàmWaardes() {
+				return values;
+			}
+			
+			@Override
+			public int teŀráàmMatrixDimensie() {
+				return dimension;
+			}
+		}
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᣳᣝᐤᣜᣳ/ᔿᣔᐪᣗᑊᕁ/NumberMatrixSet.java

@@ -0,0 +1,15 @@
+package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᣳᣝᐤᣜᣳ.ᔿᣔᐪᣗᑊᕁ;
+
+import ᒢᐩᐩ.ᒃᣔᔆᔆᒃᐤᐤᣕ.ᒼᒻᣔᙆᙆ.BãßBȍőnDuytschen注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ.Listᴿᵈ;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface NumberMatrixSet {
+	
+	@BãßBȍőnDuytschen注(中國 = "給　方面", BASIC = "GET_DIMENSION", 𓃬𓍄𓋹𓀭 = "𓎸𓎡𓈏　𓌝𓇋𓅓𓎡𓌒𓆘𓇋𓎥𓈖")
+	int geefDimensie();
+	
+	@BãßBȍőnDuytschen注(中國 = "價值觀", BASIC = "VALUES", 𓃬𓍄𓋹𓀭 = "𓅱𓅂𓃭𓅱𓋴")
+	<T extends BãßBȍőnNumberMatrixʸᴰ<T>> Listᴿᵈ<T> waardes();
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ/Appenderᵂʳ.java

@@ -0,0 +1,20 @@
+package ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Appenderᵂʳ<E> {
+
+	boolean addᵂʳ(E value);
+	
+	default boolean addAllᵂʳ(Collectionᴿᵈ<? extends E> c) {
+		boolean result = false;
+		Iteratorᴿᵈ<? extends E> iterator = c.iteratorᴿᵈ();
+		while (iterator.hatNächsteᴿᵈ()) {
+			if (addᵂʳ(iterator.nextᴿᵈ())) {
+				result = true;
+			}
+		}
+		return result;
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ/ArrayListᴿᵂ.java

@@ -0,0 +1,221 @@
+package ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Spliterator;
+import java.util.function.Consumer;
+import java.util.function.Predicate;
+import java.util.function.UnaryOperator;
+import java.util.stream.Stream;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public class ArrayListᴿᵂ<E> implements Listᵂʳ<E>,Iterable<E> {
+
+	private final List<E> data;
+	
+	public ArrayListᴿᵂ() {
+		this(new ArrayList<>());
+	}
+	
+	public ArrayListᴿᵂ(List<E> data) {
+		if (data == null) {
+			throw new NullPointerException("Can't create list with null data");
+		}
+		this.data = data;
+	}
+	
+	// ---- Iterable
+	
+	@Override
+	public Iterator<E> iterator() {
+		return data.iterator();
+	}
+	
+	// ---- Listᵂʳ
+	
+	@Override
+	public Iteratorᴿᵈ<E> iteratorᴿᵈ() {
+		return Iteratorᴿᵈ.wrapᴼᶠ(iterator());
+	}
+	
+	@Override
+	public Iteratorᵂʳ<E> iteratorᵂʳ() {
+		return Iteratorᵂʳ.wrapᴼᶠ(iterator());
+	}
+	
+	@Override
+	public boolean addᵂʳ(E value) {
+		return data.add(value);
+	}
+	
+	@Override
+	public boolean removeᵂʳ(Object o) {
+		return data.remove(o);
+	}
+	
+	@Override
+	public void addᵂʳ(int index, E element) {
+		data.add(index, element);
+	}
+	
+	@Override
+	public E removeᵂʳ(int index) {
+		return data.remove(index);
+	}
+	
+	@Override
+	public E setᵂʳ(int index, E element) {
+		return data.set(index, element);
+	}
+	
+	@Override
+	public void sortᵂʳ(Comparator<? super E> c) { // TODO: add default impl
+		data.sort(c);
+	}
+	
+	// ---- Optional, but for speed
+	
+	@Override
+	public void forEachᴿᵈ(Consumer<? super E> action) {
+		data.forEach(action);
+	}
+	
+	@Override
+	public void clearᵂʳ() {
+		data.clear();
+	}
+	
+	@Override
+	public boolean removeAllᵂʳ(Collectionᴿᵈ<?> set) {
+		return data.removeAll(set.collectionᴼᶠ());
+	}
+	
+	@Override
+	public boolean removeIfᵂʳ(Predicate<? super E> filter) {
+		return data.removeIf(filter);
+	}
+	
+	@Override
+	public boolean retainAllᵂʳ(Collectionᴿᵈ<?> set) {
+		return data.retainAll(set.collectionᴼᶠ());
+	}
+	
+	@Override
+	public E getᴿᵈ(int index) {
+		return data.get(index);
+	}
+	
+	@Override
+	public int indexOfᴿᵈ(Object o) {
+		return data.indexOf(o);
+	}
+	
+	@Override
+	public int lastIndexOfᴿᵈ(Object o) {
+		return data.lastIndexOf(o);
+	}
+	
+	@Override
+	public ListIteratorᴿᵈ<E> listIteratorᴿᵈ() {
+		return ListIteratorᴿᵈ.wrapᴼᶠ(data.listIterator());
+	}
+	
+	@Override
+	public ListIteratorᴿᵈ<E> listIteratorᴿᵈ(int index) {
+		return ListIteratorᴿᵈ.wrapᴼᶠ(data.listIterator(index));
+	}
+	
+	@Override
+	public Listᴿᵈ<E> subListᴿᵈ(int fromIndex, int toIndex) {
+		return new ArrayListᴿᵂ<>(data.subList(fromIndex, toIndex));
+	}
+	
+	@Override
+	public Object[] toArrayᴿᵈ() {
+		return data.toArray();
+	}
+	
+	@Override
+	public <T> T[] toArrayᴿᵈ(T[] arr) {
+		return data.toArray(arr);
+	}
+	
+	@Override
+	public int sizeᴿᵈ() {
+		return data.size();
+	}
+	
+	@Override
+	public boolean isEmptyᴿᵈ() {
+		return data.isEmpty();
+	}
+	
+	@Override
+	public boolean containsᴿᵈ(Object obj) {
+		return data.contains(obj);
+	}
+	
+	@Override
+	public boolean containsAllᴿᵈ(Collectionᴿᵈ<?> set) {
+		return data.containsAll(set.collectionᴼᶠ());
+	}
+	
+	@Override
+	public Stream<E> parallelStreamᴿᵈ() {
+		return data.parallelStream();
+	}
+	
+	@Override
+	public Spliterator<E> spliteratorᴿᵈ() {
+		return data.spliterator();
+	}
+	
+	@Override
+	public Stream<E> streamᴿᵈ() {
+		return data.stream();
+	}
+	
+	@Override
+	public boolean addAllᵂʳ(Collectionᴿᵈ<? extends E> c) {
+		return data.addAll(c.collectionᴼᶠ());
+	}
+	
+	@Override
+	public void forEach(Consumer<? super E> action) {
+		data.forEach(action);
+	}
+	
+	@Override
+	public Spliterator<E> spliterator() {
+		return data.spliterator();
+	}
+	
+	@Override
+	public boolean addAllᵂʳ(int index, Collectionᴿᵈ<? extends E> c) {
+		return data.addAll(index, c.collectionᴼᶠ());
+	}
+	
+	@Override
+	public void replaceAllᵂʳ(UnaryOperator<E> operator) {
+		data.replaceAll(operator);
+	}
+	
+	@Override
+	public ListIteratorᵂʳ<E> listIteratorᵂʳ() {
+		return ListIteratorᵂʳ.wrapᴼᶠ(data.listIterator());
+	}
+	
+	@Override
+	public ListIteratorᵂʳ<E> listIteratorᵂʳ(int index) {
+		return ListIteratorᵂʳ.wrapᴼᶠ(data.listIterator(index));
+	}
+	
+	@Override
+	public Listᵂʳ<E> subListᵂʳ(int fromIndex, int toIndex) {
+		return new ArrayListᴿᵂ<>(data.subList(fromIndex, toIndex));
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ/Collectionᴿᵈ.java

@@ -0,0 +1,59 @@
+package ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ;
+
+import java.util.Collection;
+import java.util.Spliterator;
+import java.util.Spliterators;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Collectionᴿᵈ<E> extends Iterableᴿᵈ<E> {
+	
+//	default NumberValue sizeBigᴿᵈ() {
+//		return null;
+//	}
+//	
+//	@Deprecated
+	default int sizeᴿᵈ() {
+		return (int) streamᴿᵈ().count();
+	}
+	
+	default boolean isEmptyᴿᵈ() {
+		return iteratorᴿᵈ().hatNächsteᴿᵈ() == false;
+	}
+	
+	default boolean containsᴿᵈ(Object obj) {
+		return streamᴿᵈ().collect(Collectors.toSet()).contains(obj);
+	}
+	
+	default boolean containsAllᴿᵈ(Collectionᴿᵈ<?> set) {
+		return streamᴿᵈ().collect(Collectors.toSet()).containsAll(set.streamᴿᵈ().collect(Collectors.toSet()));
+	}
+	
+	default Stream<E> parallelStreamᴿᵈ() {
+		return streamᴿᵈ().parallel();
+	}
+	
+	default Spliterator<E> spliteratorᴿᵈ() {
+		return Spliterators.spliteratorUnknownSize(iteratorᴿᵈ().wrapIteratorᴿᵈ(), Spliterator.ORDERED);
+	}
+	
+	default Object[] toArrayᴿᵈ() {
+		return streamᴿᵈ().collect(Collectors.toList()).toArray();
+	}
+	
+	default <T> T[] toArrayᴿᵈ(T[] arr) {
+		return streamᴿᵈ().collect(Collectors.toList()).toArray(arr);
+	}
+	
+	default Stream<E> streamᴿᵈ() {
+		return StreamSupport.stream(spliteratorᴿᵈ(), false);
+	}
+	
+	default Collection<E> collectionᴼᶠ() {
+		return streamᴿᵈ().collect(Collectors.toList());
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ/Collectionᵂʳ.java

@@ -0,0 +1,52 @@
+package ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ;
+
+import java.util.function.Predicate;
+import java.util.stream.Collectors;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Collectionᵂʳ<E> extends Collectionᴿᵈ<E>, Appenderᵂʳ<E> {
+	
+	Iteratorᵂʳ<E> iteratorᵂʳ(); // 
+	
+	boolean removeᵂʳ(Object o); //Afroussen
+	
+	default void clearᵂʳ() { // arbeitMachtFrei
+		streamᴿᵈ().collect(Collectors.toList()).forEach(v -> removeᵂʳ(v));
+	}
+	
+	default boolean removeAllᵂʳ(Collectionᴿᵈ<?> set) { // allustAfroussen
+		boolean result = false;
+		Iteratorᴿᵈ<?> iterator = set.iteratorᴿᵈ();
+		while (iterator.hatNächsteᴿᵈ()) {
+			if (removeᵂʳ(iterator.nextᴿᵈ())) {
+				result = true;
+			}
+		}
+		return result;
+	}
+	
+	default boolean removeIfᵂʳ(Predicate<? super E> filter) { // aufKnouffenAls
+		boolean result = false;
+		Iteratorᵂʳ<E> iterator = iteratorᵂʳ();
+		while (iterator.hatNächsteᴿᵈ()) {
+			if (filter.test(iterator.nextᴿᵈ())) {
+				iterator.removeᵂʳ();
+				result = true;
+			}
+		}
+		return result;
+	}
+	
+	default boolean retainAllᵂʳ(Collectionᴿᵈ<?> set) { // bewierAllusAls
+		boolean result = false;
+		for (E e:streamᴿᵈ().collect(Collectors.toList())) {
+			if (!set.containsᴿᵈ(e)) {
+				removeᵂʳ(e);
+				result = true;
+			}
+		}
+		return result;
+	}
+}

gdxapp4d-lib-bassboonyd/src/main/java/ᒢᐩᐩ/ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ/Comparatorբ.java

@@ -0,0 +1,87 @@
+package ᒢᐩᐩ.ᒼᐤᒻᒻᓫᒼᐪᑊᐤᣕᔆ;
+
+import java.util.Comparator;
+
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.Comparableբ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.Babelizeբᴬᵖᶦ;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHiero;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHinarī;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelHindi;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ßբᴬᵖᶦ.BabelMandarin;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ.ᔾᓑᣕᒼᐪᑊᐤᣕᔆ.Functionբ;
+
+@DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+public interface Comparatorբ<T> extends Comparator<T>,Babelizeբᴬᵖᶦ {
+	
+	@FunctionalInterface
+	interface ןזױזזױזזךז<יזזױזזז> extends Comparatorբ<יזזױזזז>, BabelHinarī {
+		
+		@Override
+		default int compare(יזזױזזז ךיױז, יזזױזזז יזךז) {
+			return יזדןזױזזזזך(ךיױז, יזךז);
+		}
+		
+		int יזדןזױזזזזך(יזזױזזז ךיױז, יזזױזזז יזךז);
+		
+		default ןזױזזױזזךז<יזזױזזז> זדןזױזזזזױזזז() {
+			return (ךיױז,יזךז) -> ןזױזזױזזךז.this.reversed().compare(ךיױז,יזךז);
+		}
+		
+		default ןזױזזױזזךז<יזזױזזז> זדןזױזזזזױזזױזזזזזזךז(ןזױזזױזזךז<יזזױזזז> זזזזך) {
+			return (ךיױז,יזךז) -> ןזױזזױזזךז.this.thenComparing(זזזזך).compare(ךיױז,יזךז);
+		}
+		
+		///default <U extends Comparable<? super U>> Comparator<T> 	thenComparing(Function<? super T,? extends U> keyExtractor)
+		default <זױזזזזױ extends Comparableբ.זױזזױזזזז<? super זױזזזזױ>> ןזױזזױזזךז<יזזױזזז> זדןזױזזזזױזזױזזזזזזךז(Functionբ.ױױױיךיזזז<? super יזזױזזז, ? extends זױזזזזױ> זזזזזזזזך) {
+			return (ךיױז,יזךז) -> ןזױזזױזזךז.this.thenComparing(זזזזזזזזך).compare(ךיױז,יזךז);
+		}
+		
+		// todo: add all others .....
+	}
+	
+	@FunctionalInterface
+	interface 平衡器<仿製藥> extends Comparatorբ<仿製藥>, BabelMandarin {
+		
+		@Override
+		default int compare(仿製藥 物零,仿製藥 物一) {
+			return 接受(物零,物一);
+		}
+		
+		int 接受(仿製藥 物零,仿製藥 物一);
+		
+		default 平衡器<仿製藥> 接著龸可比(平衡器<? super 仿製藥> 後) {
+			return (物零,物一) -> 平衡器.this.thenComparing(後).compare(物零,物一);
+		}
+	}
+	
+	@FunctionalInterface
+	interface संतुलक<जेनरिक> extends Comparatorբ<जेनरिक>, BabelHindi {
+		
+		@Override
+		default int compare(जेनरिक चीज़०,जेनरिक चीज़१) {
+			return मानना(चीज़०,चीज़१);
+		}
+		
+		int मानना(जेनरिक चीज़०,जेनरिक चीज़१);
+		
+		default संतुलक<जेनरिक> फिरꣻतुलनीय(संतुलक<? super जेनरिक> पीछे) {
+			return (चीज़०,चीज़१) -> संतुलक.this.thenComparing(पीछे).compare(चीज़०,चीज़१);
+		}
+	}
+	
+	@FunctionalInterface
+	interface 𓄤𓊯𓀐<𓉢> extends Comparatorբ<𓉢>, BabelHiero {
+		
+		@Override
+		default int compare(𓉢 𓐠𓐄,𓉢 𓐠𓐅) {
+			return 𓁉(𓐠𓐄,𓐠𓐅);
+		}
+		
+		int 𓁉(𓉢 𓐠𓐄,𓉢 𓐠𓐅);
+		
+		default 𓄤𓊯𓀐<𓉢> 𓂐𓐗𓌭𓍝(𓄤𓊯𓀐<? super 𓉢> 𓅀) {
+			return (𓐠𓐄,𓐠𓐅) -> 𓄤𓊯𓀐.this.thenComparing(𓅀).compare(𓐠𓐄,𓐠𓐅);
+		}
+	}
+}