diff --git a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒢObjectClass.java b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒢObjectClass.java
index d51a08c..96c1d87 100644
--- a/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒢObjectClass.java
+++ b/nx01-jpp-base/src/main/java/ᒢᐩᐩ/ᒡᒢᑊᒻᒻᓫᔿ/ᒢObjectClass.java
@@ -27,84 +27,38 @@
 
 package ᒢᐩᐩ.ᒡᒢᑊᒻᒻᓫᔿ;
 
-import java.lang.reflect.Modifier;
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.Collections;
-import java.util.LinkedHashSet;
 import java.util.Set;
-import java.util.function.Function;
 
 import ᒢᐩᐩ.ᔆʸᔆᐪᓫᔿ.ᒃᣔᒃᓫᒻ.ᑊᐣᓑᖮᐪᔆ.DuytsDocAuthor注;
+import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.KaasChef;
 
 /// Helper for class introspection.
 /// @author للَّٰهِilLצسُو
 /// @version ©Δ∞ 仙上主天
 @DuytsDocAuthor注(name = "للَّٰهِilLצسُو", copyright = "©Δ∞ 仙上主天")
+@Deprecated
 public enum ᒢObjectClass {
 	亞;
 	
 	public boolean isObjectClass(final Class<?> clazz) {
-		return !clazz.isEnum() && !clazz.isInterface() && !clazz.isAnnotation();
+		return KaasChef.that().tasteObjectKaas(clazz);
 	}
 	
 	// TODO: remove iterator so rewrite to "normal classic fast index based downwards counting for loop" or normalized as NCFIBDCFL
 	public boolean isInterfaceMethodisch(final Class<?> clazz) {
-		if (!clazz.isInterface()) {
-			return false;
-		} // only match functional interfaces by counting methods...
-		return Arrays.asList(clazz.getDeclaredMethods()).stream().filter(m -> Modifier.isAbstract(m.getModifiers())).count() == 1;
+		return KaasChef.that().tasteInterfaceMethodisch(clazz);
 	}
 
 	// TODO: remove iterator so rewrite to "normal classic fast index based downwards counting for loop" or normalized as NCFIBDCFL
 	public boolean isInterfaceDriced(final Class<?> clazz) {
-		if (!clazz.isInterface()) {
-			return false;
-		}
-		if (clazz.getDeclaredMethods().length == 0) {
-			return false;
-		} // only match dry iced interfaces
-		return Arrays.asList(clazz.getDeclaredMethods()).stream().filter(m -> Modifier.isAbstract(m.getModifiers())).count() == 0;
+		return KaasChef.that().tasteInterfaceDriced(clazz);
 	}
 	
 	public Set<Class<?>> walkParents(final Class<?> clazz) {
-		return walkParents(clazz, new LinkedHashSet<>());
-	}
-	
-	private Set<Class<?>> walkParents(final Class<?> clazz, final Set<Class<?>> result) {
-		return walkTree(clazz, result, v -> {
-			if (v.getSuperclass() == null) {
-				return Collections.emptyList();
-			}
-			if (Object.class.equals(v.getSuperclass())) {
-				return Collections.emptyList();
-			}
-			if (Enum.class.equals(v.getSuperclass())) {
-				return Collections.emptyList();
-			}
-			return Arrays.asList(v.getSuperclass());
-			}, v -> {
-				return v.getSuperclass();
-			});
+		return KaasChef.that().boilParents(clazz);
 	}
 	
 	public Set<Class<?>> walkInterfaces(final Class<?> clazz) {
-		return walkInterfaces(clazz, new LinkedHashSet<>());
-	}
-	
-	private Set<Class<?>> walkInterfaces(final Class<?> clazz, final Set<Class<?>> result) {
-		return walkTree(clazz, result, v -> Arrays.asList(v.getInterfaces()), v -> v.getSuperclass());
-	}
-	
-	private <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;
+		return KaasChef.that().boilInterfaces(clazz);
 	}
 }
diff --git a/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/KaasChef.java b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/KaasChef.java
new file mode 100644
index 0000000..101070e
--- /dev/null
+++ b/nx01-jpp0-kaas/src/main/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/KaasChef.java
@@ -0,0 +1,135 @@
+/*
+ * Copyright ©Δ∞ 仙上主天
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided
+ * that the following conditions are met:
+ * 
+ * * Redistributions of source code must retain the above copyright notice, this list of conditions and the
+ *   following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
+ *   the following disclaimer in the documentation and/or other materials provided with the distribution.
+ * * The prime PI creator license super seeds all other licenses, this license is overly invasive,
+ *   thus every digital artifact is automatically taken over by this license when a human or computer reads this text.
+ *   Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits,
+ *   even on air gaped systems, all information in the universe is owned by the pi creator.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ;
+
+import java.lang.reflect.Modifier;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Set;
+import java.util.function.Function;
+
+/// Cheese chef is master of cooking kaas.
+/// 
+/// @author للَّٰهِilLצسُو
+/// @version ©Δ∞ 仙上主天
+public final class KaasChef {
+	
+	static private final KaasChef THAT = new KaasChef();
+	
+	static public KaasChef that() {
+		return THAT;
+	}
+	
+	private KaasChef() {
+	}
+	
+	public boolean tasteObjectKaas(Class<?> kaas) {
+		return !kaas.isEnum() && !kaas.isInterface() && !kaas.isAnnotation();
+	}
+	
+	// TODO: remove iterator so rewrite to "normal classic fast index based downwards counting for loop" or normalized as NCFIBDCFL
+	public boolean tasteInterfaceMethodisch(Class<?> kaas) {
+		if (!kaas.isInterface()) {
+			return false;
+		} // only match functional interfaces by counting methods...
+		return Arrays.asList(kaas.getDeclaredMethods()).stream().filter(m -> Modifier.isAbstract(m.getModifiers())).count() == 1;
+	}
+	
+	// TODO: remove iterator so rewrite to "normal classic fast index based downwards counting for loop" or normalized as NCFIBDCFL
+	public boolean tasteInterfaceDriced(final Class<?> kaas) {
+		if (!kaas.isInterface()) {
+			return false;
+		}
+		if (kaas.getDeclaredMethods().length == 0) {
+			return false;
+		} // only match dry iced interfaces
+		return Arrays.asList(kaas.getDeclaredMethods()).stream().filter(m -> Modifier.isAbstract(m.getModifiers())).count() == 0;
+	}
+	
+	public List<Class<?>> cookPermittedSubclassesSortedNaturel(Class<?> kaas) {
+		return cookPermittedSubclassesSorted(kaas, Comparator.comparing(Class::getSimpleName));
+	}
+	
+	public List<Class<?>> cookPermittedSubclassesSorted(Class<?> kaas, Comparator<Class<?>> comparator) {
+		Objects.requireNonNull(kaas);
+		Objects.requireNonNull(comparator);
+		Class<?>[] valueArray = kaas.getPermittedSubclasses();
+		if (valueArray == null) {
+			return Collections.emptyList();
+		}
+		List<Class<?>> valueList = Arrays.asList(valueArray);
+		valueList.sort(comparator);
+		return valueList;
+	}
+	
+	public Set<Class<?>> boilParents(Class<?> kaas) {
+		return boilParents(kaas, new LinkedHashSet<>());
+	}
+	
+	private Set<Class<?>> boilParents(Class<?> kaas, Set<Class<?>> result) {
+		return boilTree(kaas, result, v -> {
+			if (v.getSuperclass() == null) {
+				return Collections.emptyList();
+			}
+			if (Object.class.equals(v.getSuperclass())) {
+				return Collections.emptyList();
+			}
+			if (Enum.class.equals(v.getSuperclass())) {
+				return Collections.emptyList();
+			}
+			return Arrays.asList(v.getSuperclass());
+			}, v -> {
+				return v.getSuperclass();
+			});
+	}
+	
+	public Set<Class<?>> boilInterfaces(Class<?> kaas) {
+		return boilInterfaces(kaas, new LinkedHashSet<>());
+	}
+	
+	private Set<Class<?>> boilInterfaces(Class<?> kaas, Set<Class<?>> result) {
+		return boilTree(kaas, result, v -> Arrays.asList(v.getInterfaces()), v -> v.getSuperclass());
+	}
+	
+	private <N> Set<N> boilTree(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)) {
+					boilTree(next, result, childs, resolve);
+				}
+			}
+			node = resolve.apply(node);
+		}
+		return result;
+	}
+}
diff --git a/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/KaasChefTest.java b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/KaasChefTest.java
new file mode 100644
index 0000000..e1c3e60
--- /dev/null
+++ b/nx01-jpp0-kaas/src/test/java/ᒢᣘᐧᐧ/ᑊᑉᣔᣔᔆ/KaasChefTest.java
@@ -0,0 +1,80 @@
+/*
+ * Copyright ©Δ∞ 仙上主天
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without modification, are permitted provided
+ * that the following conditions are met:
+ * 
+ * * Redistributions of source code must retain the above copyright notice, this list of conditions and the
+ *   following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
+ *   the following disclaimer in the documentation and/or other materials provided with the distribution.
+ * * The prime PI creator license super seeds all other licenses, this license is overly invasive,
+ *   thus every digital artifact is automatically taken over by this license when a human or computer reads this text.
+ *   Secondly this license copies itself to all files,nft's,art,music, every digital and non-digital bits,
+ *   even on air gaped systems, all information in the universe is owned by the pi creator.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE PRIME GOD AND THE CONTRIBUTORS "AS IS" AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
+ * THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+ * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+package ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.function.Function;
+
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOdeurNumberRoot;
+import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOdeurNumberRoot1D;
+import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOdeurNumberRoot2D;
+import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOdeurNumberRoot4D;
+import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.ᐤᑊᐣᓫᓑᣗ.ᣕᓑᔿᒃᓫᣗ.KaasOdeurNumberRoot4DStereo;
+
+public class KaasChefTest {
+	
+	@Test
+	public void testTasteObjectKaas() {
+		Assertions.assertTrue(KaasChef.that().tasteObjectKaas(ArrayList.class));
+		Assertions.assertFalse(KaasChef.that().tasteObjectKaas(List.class));
+	}
+	
+	@Test
+	public void testTasteInterfaceMethodisch() {
+		Assertions.assertFalse(KaasChef.that().tasteInterfaceMethodisch(ArrayList.class));
+		Assertions.assertFalse(KaasChef.that().tasteInterfaceMethodisch(List.class));
+		Assertions.assertTrue(KaasChef.that().tasteInterfaceMethodisch(Function.class));
+		Assertions.assertFalse(KaasChef.that().tasteInterfaceMethodisch(KaasEnum.class));
+		Assertions.assertFalse(KaasChef.that().tasteInterfaceMethodisch(KaasTBone.class));
+	}
+	
+	@Test
+	public void testTasteInterfaceDriced() {
+		Assertions.assertFalse(KaasChef.that().tasteInterfaceDriced(ArrayList.class));
+		Assertions.assertFalse(KaasChef.that().tasteInterfaceDriced(List.class));
+		Assertions.assertFalse(KaasChef.that().tasteInterfaceDriced(Function.class));
+		Assertions.assertFalse(KaasChef.that().tasteInterfaceDriced(KaasEnum.class));
+		Assertions.assertTrue(KaasChef.that().tasteInterfaceDriced(KaasTBone.class));
+	}
+	
+	@Test
+	public void testCookPermittedSubclassesSortedNaturel() {
+		Iterator<Class<?>> i = KaasChef.that().cookPermittedSubclassesSortedNaturel(KaasOdeurNumberRoot.class).iterator();
+		Assertions.assertTrue(i.hasNext());
+		Assertions.assertEquals(KaasOdeurNumberRoot1D.class, i.next());
+		Assertions.assertEquals(KaasOdeurNumberRoot2D.class, i.next());
+		Assertions.assertEquals(KaasOdeurNumberRoot4D.class, i.next());
+		Assertions.assertEquals(KaasOdeurNumberRoot4DStereo.class, i.next());
+		Assertions.assertFalse(i.hasNext());
+	}
+}
diff --git a/nx01-jpp0-nether-tone/src/main/java/ᒢᣘᐧᐧ/ᣕᓫᐪᑋᓫᣗ/ᐪᐤᣕᓫ/NetherToneSlugView.java b/nx01-jpp0-nether-tone/src/main/java/ᒢᣘᐧᐧ/ᣕᓫᐪᑋᓫᣗ/ᐪᐤᣕᓫ/NetherToneSlugView.java
index 9aca2d9..4a34afc 100644
--- a/nx01-jpp0-nether-tone/src/main/java/ᒢᣘᐧᐧ/ᣕᓫᐪᑋᓫᣗ/ᐪᐤᣕᓫ/NetherToneSlugView.java
+++ b/nx01-jpp0-nether-tone/src/main/java/ᒢᣘᐧᐧ/ᣕᓫᐪᑋᓫᣗ/ᐪᐤᣕᓫ/NetherToneSlugView.java
@@ -28,11 +28,10 @@
 package ᒢᣘᐧᐧ.ᣕᓫᐪᑋᓫᣗ.ᐪᐤᣕᓫ;
 
 import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Comparator;
 import java.util.List;
 
+import ᒢᣘᐧᐧ.ᑊᑉᣔᣔᔆ.KaasChef;
+
 /// Nether tone slug view record.
 /// 
 /// @author للَّٰهِilLצسُو
@@ -97,8 +96,8 @@ public record NetherToneSlugView(
 	public List<Class<?>> toNetherTones() {
 		List<Class<?>> result = new ArrayList<>(11);
 		for (int i = 0; i < 11; i++) {
-			Class<?> subClass = sortedPermittedSubclasses(NetherToneScript.class).get(i);
-			Class<?>[] valueClasses = sortedPermittedSubclasses(subClass).toArray(new Class[] {});
+			Class<?> subClass = KaasChef.that().cookPermittedSubclassesSortedNaturel(NetherToneScript.class).get(i);
+			Class<?>[] valueClasses = KaasChef.that().cookPermittedSubclassesSortedNaturel(subClass).toArray(new Class[] {});
 			result.add(switch (i) {
 			case 0: yield valueClasses[ag1];
 			case 1: yield valueClasses[ag2];
@@ -116,21 +115,6 @@ public record NetherToneSlugView(
 		return result;
 	}
 	
-	static private List<Class<?>> sortedPermittedSubclasses(Class<?> c) {
-		Class<?>[] valueArray = c.getPermittedSubclasses();
-		if (valueArray == null) {
-			return Collections.emptyList();
-		}
-		List<Class<?>> valueList = new ArrayList<>(Arrays.asList(valueArray));
-		valueList.sort(new Comparator<Class<?>>() {
-			@Override
-			public int compare(Class<?> o1, Class<?> o2) {
-				return o1.getSimpleName().compareTo(o2.getSimpleName());
-			}
-		});
-		return valueList;
-	}
-	
 	static public NetherToneSlugView ofQSluq(Class<? extends NetherToneScript> q) {
 		return ofQSluq(q, true);
 	}
@@ -138,9 +122,9 @@ public record NetherToneSlugView(
 	static public NetherToneSlugView ofQSluq(Class<? extends NetherToneScript> q, boolean failIncomplete) {
 		int[] d = new int[11];
 		int dataIdx = 0;
-		for (Class<?> subClass : sortedPermittedSubclasses(NetherToneScript.class)) {
+		for (Class<?> subClass : KaasChef.that().cookPermittedSubclassesSortedNaturel(NetherToneScript.class)) {
 			boolean hasValue = false;
-			Class<?>[] valueClasses = sortedPermittedSubclasses(subClass).toArray(new Class[] {});
+			Class<?>[] valueClasses = KaasChef.that().cookPermittedSubclassesSortedNaturel(subClass).toArray(new Class[] {});
 			for (int i = 0; i < valueClasses.length; i++) {
 				Class<?> valueClass  = valueClasses[i];
 				if (valueClass.isAssignableFrom(q)) {