- All definitions are now also module-aware (will be use for binary module serialization & access checks)

- Fixing function expressions not being properly linked to their functional interface

CodeFormatter/src/main/java/org/openzen/zenscript/formatter/FormattingUtils.java

 import org.openzen.zenscript.codemodel.Modifiers;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.statement.BlockStatement;
 import org.openzen.zenscript.codemodel.statement.BreakStatement;
 				result.append(parameter.name);
 				
 				if (parameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : parameter.bounds) {
+					for (TypeParameterBound bound : parameter.bounds) {
 						result.append(": ");
 						result.append(bound.accept(typeFormatter));
 					}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/HighLevelDefinition.java

 import org.openzen.zenscript.codemodel.definition.DefinitionVisitor;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
+import org.openzen.zenscript.codemodel.definition.MemberCollector;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.ConstructorMember;
  */
 public abstract class HighLevelDefinition extends Taggable {
 	public final CodePosition position;
+	public final Module module;
 	public final ZSPackage pkg;
 	public final String name;
 	public final int modifiers;
 	
 	private boolean isDestructible = false;
 	
-	public HighLevelDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+	public HighLevelDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		if (module == null)
+			throw new NullPointerException();
+		
 		this.position = position;
+		this.module = module;
 		this.pkg = pkg;
 		this.name = name;
 		this.modifiers = modifiers;
 			members.add(member);
 	}
 	
+	public void collectMembers(MemberCollector collector) {
+		for (IDefinitionMember member : members)
+			collector.member(member);
+	}
+	
 	public boolean isDestructible() {
 		boolean isDestructible = false;
 		for (IDefinitionMember member : members) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/Module.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel;
+
+import org.openzen.zencode.shared.Taggable;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public class Module extends Taggable {
+	public static final Module BUILTIN = new Module("builtin");
+	
+	public final String name;
+	
+	public Module(String name) {
+		this.name = name;
+	}
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/context/CompilingPackage.java

 import java.util.List;
 import java.util.Map;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.codemodel.type.DefinitionTypeID;
 import org.openzen.zenscript.codemodel.type.GenericName;
  * @author Hoofdgebruiker
  */
 public class CompilingPackage {
+	public final Module module;
 	private final ZSPackage pkg;
 	private final Map<String, CompilingPackage> packages = new HashMap<>();
 	private final Map<String, CompilingType> types = new HashMap<>();
 	
-	public CompilingPackage(ZSPackage pkg) {
+	public CompilingPackage(ZSPackage pkg, Module module) {
 		this.pkg = pkg;
+		this.module = module;
 	}
 	
 	public ZSPackage getPackage() {
 		if (packages.containsKey(name))
 			return packages.get(name);
 		
-		CompilingPackage newPackage = new CompilingPackage(pkg.getOrCreatePackage(name));
+		CompilingPackage newPackage = new CompilingPackage(pkg.getOrCreatePackage(name), module);
 		packages.put(name, newPackage);
 		return newPackage;
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/AliasDefinition.java

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.scope.TypeScope;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 public class AliasDefinition extends HighLevelDefinition {
 	public ITypeID type;
 	
-	public AliasDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public AliasDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void setType(ITypeID type) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/ClassDefinition.java

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
-import org.openzen.zenscript.codemodel.scope.TypeScope;
-import org.openzen.zenscript.codemodel.type.ITypeID;
+import org.openzen.zenscript.codemodel.Module;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ClassDefinition extends HighLevelDefinition {
-	public ClassDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers) {
-		this(position, pkg, name, modifiers, null);
+	public ClassDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers) {
+		this(position, module, pkg, name, modifiers, null);
 	}
 	
-	public ClassDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public ClassDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/EnumDefinition.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.EnumConstantMember;
 
 /**
 public class EnumDefinition extends HighLevelDefinition {
 	public List<EnumConstantMember> enumConstants = new ArrayList<>();
 	
-	public EnumDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public EnumDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override
 		return visitor.visitEnum(this);
 	}
 	
+	@Override
+	public void collectMembers(MemberCollector collector) {
+		super.collectMembers(collector);
+		
+		for (EnumConstantMember member : enumConstants)
+			collector.enumConstant(member);
+	}
+	
 	public void addEnumConstant(EnumConstantMember constant) {
 		enumConstants.add(constant);
 	}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/ExpansionDefinition.java

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 public class ExpansionDefinition extends HighLevelDefinition {
 	public ITypeID target;
 	
-	public ExpansionDefinition(CodePosition position, ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, null, modifiers, outerDefinition);
+	public ExpansionDefinition(CodePosition position, Module module, ZSPackage pkg, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, null, modifiers, outerDefinition);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/FunctionDefinition.java

 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.statement.Statement;
 	public CallerMember caller;
 	public final DefinitionMemberGroup callerGroup;
 	
-	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public FunctionDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 		callerGroup = new DefinitionMemberGroup(true, name);
 	}
 	
-	public FunctionDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, FunctionHeader header) {
-		this(position, pkg, name, modifiers, (HighLevelDefinition) null);
+	public FunctionDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, FunctionHeader header) {
+		this(position, module, pkg, name, modifiers, (HighLevelDefinition) null);
 		setHeader(header);
 	}
 	

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/InterfaceDefinition.java

 import java.util.List;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 /**
 public class InterfaceDefinition extends HighLevelDefinition {
 	public final List<ITypeID> baseInterfaces = new ArrayList<>();
 	
-	public InterfaceDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public InterfaceDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 	
 	public void addBaseInterface(ITypeID baseInterface) {

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/MemberCollector.java

+/*
+ * To change this license header, choose License Headers in Project Properties.
+ * To change this template file, choose Tools | Templates
+ * and open the template in the editor.
+ */
+package org.openzen.zenscript.codemodel.definition;
+
+import org.openzen.zenscript.codemodel.member.EnumConstantMember;
+import org.openzen.zenscript.codemodel.member.IDefinitionMember;
+
+/**
+ *
+ * @author Hoofdgebruiker
+ */
+public interface MemberCollector {
+	void member(IDefinitionMember member);
+	
+	void enumConstant(EnumConstantMember member);
+	
+	void variantOption(VariantDefinition.Option member);
+}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/StructDefinition.java

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class StructDefinition extends HighLevelDefinition {
-	public StructDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public StructDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override

CodeModel/src/main/java/org/openzen/zenscript/codemodel/definition/VariantDefinition.java

 import org.openzen.zencode.shared.Taggable;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.member.ref.VariantOptionRef;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 
 public class VariantDefinition extends HighLevelDefinition {
 	public final List<Option> options = new ArrayList<>();
 	
-	public VariantDefinition(CodePosition position, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
-		super(position, pkg, name, modifiers, outerDefinition);
+	public VariantDefinition(CodePosition position, Module module, ZSPackage pkg, String name, int modifiers, HighLevelDefinition outerDefinition) {
+		super(position, module, pkg, name, modifiers, outerDefinition);
 	}
 
 	@Override
 		return visitor.visitVariant(this);
 	}
 	
+	@Override
+	public void collectMembers(MemberCollector collector) {
+		super.collectMembers(collector);
+		
+		for (Option option : options)
+			collector.variantOption(option);
+	}
+	
 	public static class Option extends Taggable {
 		public final String name;
 		public final int ordinal;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterSuperBound.java

  *
  * @author Hoofdgebruiker
  */
-public class ParameterSuperBound extends GenericParameterBound {
+public class ParameterSuperBound extends TypeParameterBound {
 	public final ITypeID type;
 	
 	public ParameterSuperBound(ITypeID type) {
 	}
 
 	@Override
-	public GenericParameterBound instance(GenericMapper mapper) {
+	public TypeParameterBound instance(GenericMapper mapper) {
 		ITypeID translated = type.instance(mapper);
 		if (translated == type)
 			return this;

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/ParameterTypeBound.java

  *
  * @author Hoofdgebruiker
  */
-public class ParameterTypeBound extends GenericParameterBound {
+public class ParameterTypeBound extends TypeParameterBound {
 	public final CodePosition position;
 	public final ITypeID type;
 	
 	}
 
 	@Override
-	public GenericParameterBound instance(GenericMapper mapper) {
+	public TypeParameterBound instance(GenericMapper mapper) {
 		return new ParameterTypeBound(position, type.instance(mapper));
 	}
 

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameter.java

 	
 	public final CodePosition position;
 	public final String name;
-	public final List<GenericParameterBound> bounds = new ArrayList<>();
+	public final List<TypeParameterBound> bounds = new ArrayList<>();
 	
 	public TypeParameter(CodePosition position, String name) {
 		this.position = position;
 		this.name = name;
 	}
 	
-	private TypeParameter(CodePosition position, String name, List<GenericParameterBound> bounds) {
+	private TypeParameter(CodePosition position, String name, List<TypeParameterBound> bounds) {
 		this.position = position;
 		this.name = name;
 		bounds.addAll(bounds);
 	}
 	
-	public void addBound(GenericParameterBound bound) {
+	public void addBound(TypeParameterBound bound) {
 		bounds.add(bound);
 	}
 	
 	public boolean isObjectType() {
-		for (GenericParameterBound bound : bounds)
+		for (TypeParameterBound bound : bounds)
 			if (bound.isObjectType())
 				return true;
 		
 	}
 	
 	public boolean matches(LocalMemberCache cache, ITypeID type) {
-		for (GenericParameterBound bound : bounds) {
+		for (TypeParameterBound bound : bounds) {
 			if (!bound.matches(cache, type))
 				return false;
 		}
 	public String getCanonical() {
 		StringBuilder result = new StringBuilder();
 		result.append(name);
-		for(GenericParameterBound bound : bounds) {
+		for(TypeParameterBound bound : bounds) {
 			result.append(':');
 			result.append(bound.getCanonical());
 		}

CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/GenericParameterBound.java → CodeModel/src/main/java/org/openzen/zenscript/codemodel/generic/TypeParameterBound.java

  *
  * @author Hoofdgebruiker
  */
-public abstract class GenericParameterBound {
+public abstract class TypeParameterBound {
 	public abstract boolean isObjectType();
 	
 	public abstract <T> T accept(GenericParameterBoundVisitor<T> visitor);
 	
 	public abstract boolean matches(LocalMemberCache cache, ITypeID type);
 	
-	public abstract GenericParameterBound instance(GenericMapper mapper);
+	public abstract TypeParameterBound instance(GenericMapper mapper);
 	
 	public abstract String getCanonical();
 }

CodeModel/src/main/java/org/openzen/zenscript/codemodel/type/member/TypeMemberBuilder.java

 import org.openzen.zenscript.codemodel.expression.ConstantUShortExpression;
 import org.openzen.zenscript.codemodel.expression.EnumConstantExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.member.CallerMember;
 import org.openzen.zenscript.codemodel.member.CasterMember;
 import static org.openzen.zencode.shared.CodePosition.BUILTIN;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.definition.InterfaceDefinition;
 import org.openzen.zenscript.codemodel.expression.ConstantUSizeExpression;
 import org.openzen.zenscript.codemodel.member.IteratorMember;
 
 	@Override
 	public Void visitArray(ArrayTypeID array) {
-		HighLevelDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		HighLevelDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		ITypeID baseType = array.elementType;
 		int dimension = array.dimension;
 
 		ITypeID keyType = assoc.keyType;
 		ITypeID valueType = assoc.valueType;
 		
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		
 		constructor(builtin, ASSOC_CONSTRUCTOR);
 
 		FunctionHeader putHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BasicTypeID.VOID, null, new FunctionParameter(valueType));
 		FunctionHeader containsHeader = new FunctionHeader(new TypeParameter[] { functionParameter }, BasicTypeID.BOOL, null, new FunctionParameter[0]);
 		
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		constructor(builtin, GENERICMAP_CONSTRUCTOR);
 		
 		method(builtin, "getOptional", getOptionalHeader, GENERICMAP_GETOPTIONAL);
 
 	@Override
 	public Void visitFunction(FunctionTypeID function) {
-		FunctionDefinition builtin = new FunctionDefinition(BUILTIN, null, "", Modifiers.EXPORT, function.header);
+		FunctionDefinition builtin = new FunctionDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT, function.header);
 		new CallerMember(BUILTIN, builtin, 0, function.header, FUNCTION_CALL).registerTo(members, TypeMemberPriority.SPECIFIED, null);
 		
 		same(builtin, FUNCTION_SAME, function);
 	public Void visitGeneric(GenericTypeID generic) {
 		TypeParameter parameter = generic.parameter;
 
-		for (GenericParameterBound bound : parameter.bounds) {
+		for (TypeParameterBound bound : parameter.bounds) {
 			bound.registerMembers(cache, members);
 		}
 		
 	public Void visitRange(RangeTypeID range) {
 		ITypeID baseType = range.baseType;
 
-		ClassDefinition definition = new ClassDefinition(BUILTIN, null, "", Modifiers.EXPORT);
+		ClassDefinition definition = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "", Modifiers.EXPORT);
 		getter(definition, RANGE_FROM, "from", baseType);
 		getter(definition, RANGE_TO, "to", baseType);
 		if (baseType == BYTE
 
 	@Override
 	public Void visitModified(ModifiedTypeID modified) {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "modified", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "modified", Modifiers.EXPORT, null);
 		modified.baseType.accept(this);
 		
 		if (modified.isOptional()) {
 	}
 	
 	private void visitBool() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "bool", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "bool", Modifiers.EXPORT, null);
 		not(builtin, BOOL_NOT, BOOL);
 		and(builtin, BOOL_AND, BOOL, BOOL);
 		or(builtin, BOOL_OR, BOOL, BOOL);
 	}
 	
 	private void visitByte() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "byte", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "byte", Modifiers.EXPORT, null);
 		
 		invert(builtin, BYTE_NOT, BYTE);
 		inc(builtin, BYTE_INC, BYTE);
 	}
 	
 	private void visitSByte() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "sbyte", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "sbyte", Modifiers.EXPORT, null);
 		
 		invert(builtin, SBYTE_NOT, SBYTE);
 		neg(builtin, SBYTE_NEG, SBYTE);
 	}
 	
 	private void visitShort() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "short", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "short", Modifiers.EXPORT, null);
 		
 		invert(builtin, SHORT_NOT, SHORT);
 		neg(builtin, SHORT_NEG, SHORT);
 	}
 	
 	private void visitUShort() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "ushort", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ushort", Modifiers.EXPORT, null);
 		
 		invert(builtin, USHORT_NOT, USHORT);
 		inc(builtin, USHORT_INC, USHORT);
 	}
 	
 	private void visitInt() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "int", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "int", Modifiers.EXPORT, null);
 		
 		invert(builtin, INT_NOT, INT);
 		neg(builtin, INT_NEG, INT);
 	}
 
 	private void visitUInt() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "uint", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "uint", Modifiers.EXPORT, null);
 		
 		invert(builtin, UINT_NOT, INT);
 		inc(builtin, UINT_DEC, INT);
 	}
 	
 	private void visitLong() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "long", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "long", Modifiers.EXPORT, null);
 		
 		invert(builtin, LONG_NOT, LONG);
 		neg(builtin, LONG_NEG, LONG);
 	}
 	
 	private void visitULong() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "ulong", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "ulong", Modifiers.EXPORT, null);
 		
 		invert(builtin, ULONG_NOT, ULONG);
 		inc(builtin, ULONG_DEC, ULONG);
 	}
 	
 	private void visitUSize() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "usize", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "usize", Modifiers.EXPORT, null);
 		
 		invert(builtin, USIZE_NOT, USIZE);
 		inc(builtin, USIZE_DEC, USIZE);
 	}
 	
 	private void visitFloat() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "float", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "float", Modifiers.EXPORT, null);
 		
 		neg(builtin, FLOAT_NEG, FLOAT);
 		inc(builtin, FLOAT_DEC, FLOAT);
 	}
 	
 	private void visitDouble() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "double", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "double", Modifiers.EXPORT, null);
 		
 		neg(builtin, DOUBLE_NEG, DOUBLE);
 		inc(builtin, DOUBLE_DEC, DOUBLE);
 	}
 
 	private void visitChar() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "char", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "char", Modifiers.EXPORT, null);
 		
 		add(builtin, CHAR_ADD_INT, INT, CHAR);
 		sub(builtin, CHAR_SUB_INT, INT, CHAR);
 	}
 
 	private void visitString() {
-		ClassDefinition builtin = new ClassDefinition(BUILTIN, null, "string", Modifiers.EXPORT, null);
+		ClassDefinition builtin = new ClassDefinition(BUILTIN, Module.BUILTIN, null, "string", Modifiers.EXPORT, null);
 		
 		constructor(builtin, STRING_CONSTRUCTOR_CHARACTERS, registry.getArray(CHAR, 1));
 		

CompilerShared/src/main/java/org/openzen/zenscript/compiler/SemanticModule.java

 import java.util.function.Consumer;
 import org.openzen.zenscript.codemodel.annotations.AnnotationDefinition;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.PackageDefinitions;
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.annotations.AnnotationProcessor;
 	public final SemanticModule[] dependencies;
 	
 	private State state;
+	public final Module module;
 	public final ZSPackage rootPackage;
 	public final ZSPackage modulePackage;
 	public final PackageDefinitions definitions;
 	
 	public SemanticModule(
 			String name,
+			Module module,
 			SemanticModule[] dependencies,
 			State state,
 			ZSPackage rootPackage,
 			AnnotationDefinition[] annotations)
 	{
 		this.name = name;
+		this.module = module;
 		this.dependencies = dependencies;
 		
 		this.state = state;
 		
 		return new SemanticModule(
 				name,
+				module,
 				dependencies,
 				State.NORMALIZED,
 				rootPackage,

Constructor/src/main/java/org/openzen/zenscript/constructor/Module.java → Constructor/src/main/java/org/openzen/zenscript/constructor/ParsedModule.java

  *
  * @author Hoofdgebruiker
  */
-public class Module {
+public class ParsedModule {
 	public final String name;
 	public final String[] dependencies;
 	public final File sourceDirectory;
 	public final String host;
 	private final Consumer<CompileException> exceptionLogger;
 	
-	public Module(String name, File directory, File moduleFile, Consumer<CompileException> exceptionLogger) throws IOException {
+	public ParsedModule(String name, File directory, File moduleFile, Consumer<CompileException> exceptionLogger) throws IOException {
 		this.name = name;
 		this.sourceDirectory = new File(directory, "src");
 		this.exceptionLogger = exceptionLogger;

Constructor/src/main/java/org/openzen/zenscript/constructor/module/DirectoryModuleReference.java

 import org.json.JSONObject;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.FileSourceFile;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 import org.openzen.zenscript.codemodel.definition.ZSPackage;
 import org.openzen.zenscript.compiler.CompilationUnit;
 import org.openzen.zenscript.constructor.ConstructorException;
 import org.openzen.zenscript.constructor.JSONUtils;
-import org.openzen.zenscript.constructor.Module;
+import org.openzen.zenscript.constructor.ParsedModule;
 import org.openzen.zenscript.constructor.ModuleLoader;
 import org.openzen.zenscript.codemodel.type.TypeSymbol;
 import org.openzen.zenscript.parser.ParsedFile;
 				space.addModule(dependencyName, module);
 			}
 
-			Module module = new Module(moduleName, directory, jsonFile, exceptionLogger);
-			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, module.packageName);
-			CompilingPackage compilingPackage = new CompilingPackage(pkg);
+			ParsedModule parsedModule = new ParsedModule(moduleName, directory, jsonFile, exceptionLogger);
+			ZSPackage pkg = isStdlib ? unit.globalTypeRegistry.stdlib : new ZSPackage(null, parsedModule.packageName);
+			Module module = new Module(moduleName);
+			CompilingPackage compilingPackage = new CompilingPackage(pkg, module);
 			
-			ParsedFile[] parsedFiles = module.parse(compilingPackage);
-			SemanticModule result = ParsedFile.compileSyntaxToSemantic(module.name, dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
+			ParsedFile[] parsedFiles = parsedModule.parse(compilingPackage);
+			SemanticModule result = ParsedFile.compileSyntaxToSemantic(parsedModule.name, dependencies, compilingPackage, parsedFiles, space, exceptionLogger);
 			
 			JSONObject globals = json.optJSONObject("globals");
 			if (globals != null) {

JavaBytecodeCompiler/src/main/java/org/openzen/zenscript/javabytecode/compiler/JavaExpressionVisitor.java

 
 		final JavaMethod methodInfo = JavaMethod.getNativeVirtual(javaWriter.method.cls, "accept", signature);
 		final ClassWriter lambdaCW = new ClassWriter(ClassWriter.COMPUTE_FRAMES);
-		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{JavaSynthesizedClassNamer.createFunctionName(new FunctionTypeID(null, expression.header)).cls.internalName});
+		lambdaCW.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, name, null, "java/lang/Object", new String[]{context.getInternalName(new FunctionTypeID(null, expression.header))});
 		final JavaWriter functionWriter = new JavaWriter(lambdaCW, methodInfo, null, signature, null, "java/lang/Override");
 		
 		javaWriter.newObject(name);

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaTypeDescriptorVisitor.java

 package org.openzen.zenscript.javashared;
 
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.type.*;
 
 
     @Override
     public String visitGeneric(GenericTypeID generic) {
-		for (GenericParameterBound bound : generic.parameter.bounds) {
+		for (TypeParameterBound bound : generic.parameter.bounds) {
 			if (bound instanceof ParameterTypeBound) {
 				return ((ParameterTypeBound) bound).type.accept(this);
 			}

JavaShared/src/main/java/org/openzen/zenscript/javashared/JavaTypeInternalNameVisitor.java

 package org.openzen.zenscript.javashared;
 
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.codemodel.type.*;
 
 
     @Override
     public String visitGeneric(GenericTypeID generic) {
-		for (GenericParameterBound bound : generic.parameter.bounds) {
+		for (TypeParameterBound bound : generic.parameter.bounds) {
 			if (bound instanceof ParameterTypeBound) {
 				return ((ParameterTypeBound) bound).type.accept(this);
 			}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/FormattingUtils.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.Expression;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.TypeParameter;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 				result.append(parameter.name);
 				
 				if (parameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : parameter.bounds) {
+					for (TypeParameterBound bound : parameter.bounds) {
 						result.append(": ");
 						result.append(bound.accept(typeFormatter));
 					}

JavaSourceCompiler/src/main/java/org/openzen/zenscript/javasource/JavaSourceUtils.java

  */
 package org.openzen.zenscript.javasource;
 
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 			output.append(typeParameter.name);
 			
 			if (typeParameter.bounds.size() > 0) {
-				for (GenericParameterBound bound : typeParameter.bounds)
+				for (TypeParameterBound bound : typeParameter.bounds)
 					bound.accept(boundVisitor);
 			}
 		}
 				output.append(typeParameter.name);
 
 				if (typeParameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : typeParameter.bounds)
+					for (TypeParameterBound bound : typeParameter.bounds)
 						bound.accept(boundVisitor);
 				}
 			}
 				output.append(typeParameter.name);
 
 				if (typeParameter.bounds.size() > 0) {
-					for (GenericParameterBound bound : typeParameter.bounds)
+					for (TypeParameterBound bound : typeParameter.bounds)
 						bound.accept(boundVisitor);
 				}
 			}

Parser/src/main/java/org/openzen/zenscript/parser/ParsedFile.java

 		}
 		
 		if (failed)
-			return new SemanticModule(name, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
+			return new SemanticModule(name, pkg.module, dependencies, SemanticModule.State.INVALID, rootPackage, pkg.getPackage(), definitions, Collections.emptyList(), registry.compilationUnit, expansions, registry.getAnnotations());
 		
 		// scripts will store all the script blocks encountered in the files
 		PrecompilationState precompiler = new PrecompilationState();
 			}
 		}
 		
-		return new SemanticModule(name, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg.getPackage(), definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
+		return new SemanticModule(name, pkg.module, dependencies, SemanticModule.State.ASSEMBLED, rootPackage, pkg.getPackage(), definitions, scripts, registry.compilationUnit, expansions, registry.getAnnotations());
 	}
 	
 	public static ParsedFile parse(CompilingPackage compilingPackage, BracketExpressionParser bracketParser, File file) throws IOException {

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedAlias.java

 		this.parameters = parameters;
 		this.type = type;
 		
-		compiled = new AliasDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new AliasDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		
 		if (parameters != null && parameters.size() > 0) {
 			TypeParameter[] typeParameters = new TypeParameter[parameters.size()];

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedClass.java

 		this.parameters = parameters;
 		this.superclass = superclass;
 		
-		compiled = new ClassDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new ClassDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(parameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedEnum.java

 	public ParsedEnum(CompilingPackage pkg, CodePosition position, int modifiers, ParsedAnnotation[] annotations, String name, HighLevelDefinition outerDefinition) {
 		super(position, modifiers, pkg, annotations);
 		
-		compiled = new EnumDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new EnumDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 	
 	public void addEnumValue(ParsedEnumConstant value) {

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedExpansion.java

 		this.parameters = genericParameters;
 		this.target = target;
 		
-		compiled = new ExpansionDefinition(position, pkg.getPackage(), modifiers, outerDefinition);
+		compiled = new ExpansionDefinition(position, pkg.module, pkg.getPackage(), modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
 	}
 	

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedFunction.java

 		this.header = header;
 		this.body = body;
 		
-		compiled = new FunctionDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new FunctionDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 	}
 
 	@Override

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedGenericBound.java

 package org.openzen.zenscript.parser.definitions;
 
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public abstract class ParsedGenericBound {
-	public abstract GenericParameterBound compile(TypeResolutionContext context);
+	public abstract TypeParameterBound compile(TypeResolutionContext context);
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedInterface.java

 		this.typeParameters = typeParameters;
 		this.superInterfaces = superInterfaces;
 		
-		compiled = new InterfaceDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new InterfaceDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(typeParameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedStruct.java

 		
 		this.parameters = genericParameters;
 		
-		compiled = new StructDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new StructDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(genericParameters));
 	}
 

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedSuperBound.java

 package org.openzen.zenscript.parser.definitions;
 
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 	}
 
 	@Override
-	public GenericParameterBound compile(TypeResolutionContext context) {
+	public TypeParameterBound compile(TypeResolutionContext context) {
 		return new ParameterSuperBound(type.compile(context));
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedTypeBound.java

 
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 import org.openzen.zenscript.parser.type.IParsedType;
 
 	}
 
 	@Override
-	public GenericParameterBound compile(TypeResolutionContext context) {
+	public TypeParameterBound compile(TypeResolutionContext context) {
 		return new ParameterTypeBound(position, type.compile(context));
 	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/definitions/ParsedVariant.java

 		super(position, modifiers, pkg, annotations);
 		
 		this.typeParameters = typeParameters;
-		compiled = new VariantDefinition(position, pkg.getPackage(), name, modifiers, outerDefinition);
+		compiled = new VariantDefinition(position, pkg.module, pkg.getPackage(), name, modifiers, outerDefinition);
 		compiled.setTypeParameters(ParsedTypeParameter.getCompiled(typeParameters));
 	}
 	

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/GlobalRegistry.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.GenericMapper;
 import org.openzen.zenscript.codemodel.Modifiers;
+import org.openzen.zenscript.codemodel.Module;
 import org.openzen.zenscript.codemodel.context.TypeResolutionContext;
 import org.openzen.zenscript.codemodel.definition.ClassDefinition;
 import org.openzen.zenscript.codemodel.definition.ExpansionDefinition;
 			// eg. package my.package with a class MyClass with a single native method test() returning a string
 			// the visitors can then during compilation check if a method is an instance of NativeMethodMember and treat it accordingly
 			ZSPackage packageMyPackage = rootPackage.getOrCreatePackage("my").getOrCreatePackage("test");
-			ClassDefinition myClassDefinition = new ClassDefinition(CodePosition.NATIVE, packageMyPackage, "MyClass", Modifiers.PUBLIC, null);
+			ClassDefinition myClassDefinition = new ClassDefinition(CodePosition.NATIVE, MODULE, packageMyPackage, "MyClass", Modifiers.PUBLIC, null);
 			JavaClass myClassInfo = new JavaClass("my.test", "MyClass", JavaClass.Kind.CLASS);
 			
 			MethodMember member = new MethodMember(CodePosition.NATIVE, myClassDefinition, Modifiers.PUBLIC, "test", new FunctionHeader(BasicTypeID.STRING), null);
 		return globals;
 	}
 	
-	private final ClassDefinition PRINTSTREAM = new ClassDefinition(CodePosition.NATIVE, javaIo, "PrintStream", Modifiers.EXPORT);
-	private final ClassDefinition SYSTEM = new ClassDefinition(CodePosition.NATIVE, javaLang, "System", Modifiers.EXPORT);
+	private final Module MODULE = new Module("scriptingExample");
+	private final ClassDefinition PRINTSTREAM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaIo, "PrintStream", Modifiers.EXPORT);
+	private final ClassDefinition SYSTEM = new ClassDefinition(CodePosition.NATIVE, MODULE, javaLang, "System", Modifiers.EXPORT);
 	private final MethodMember PRINTSTREAM_PRINTLN = new MethodMember(
 			CodePosition.NATIVE,
 			PRINTSTREAM,

ScriptingExample/src/main/java/org/openzen/zenscript/scriptingexample/Main.java

 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.SourceFile;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
+import org.openzen.zenscript.codemodel.Module;
 
 import org.openzen.zenscript.codemodel.ScriptBlock;
 import org.openzen.zenscript.codemodel.context.CompilingPackage;
 		File[] inputFiles = Optional.ofNullable(inputDirectory.listFiles((dir, name) -> name.endsWith(".zs"))).orElseGet(() -> new File[0]);
 		
 		ZSPackage pkg = new ZSPackage(null, "");
-		CompilingPackage compilingPkg = new CompilingPackage(pkg);
+		Module module = new Module("scripts");
+		CompilingPackage compilingPkg = new CompilingPackage(pkg, module);
 		ParsedFile[] parsedFiles = parse(compilingPkg, inputFiles);
 		
 		ZSPackage global = new ZSPackage(null, "");
 		GlobalRegistry registry = new GlobalRegistry(global);
-		SemanticModule module = compileSyntaxToSemantic(compilingPkg, parsedFiles, registry);
+		SemanticModule semantic = compileSyntaxToSemantic(compilingPkg, parsedFiles, registry);
 		
 		//formatFiles(pkg, module);
 		
-		if (module.isValid()) {
-			JavaModule javaModule = compileSemanticToJava(module);
+		if (semantic.isValid()) {
+			JavaModule javaModule = compileSemanticToJava(semantic);
 			javaModule.execute();
 		} else {
 			System.out.println("There were compilation errors");

Shared/src/main/java/compactio/CompactBytesDataInput.java

+package compactio;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+public final class CompactBytesDataInput implements CompactDataInput, AutoCloseable {
+    private static final int P6 = 1 << 6;
+    private static final int P7 = 1 << 7;
+    private static final int P13 = 1 << 13;
+    private static final int P14 = 1 << 14;
+    private static final int P20 = 1 << 20;
+    private static final int P21 = 1 << 21;
+    private static final int P27 = 1 << 27;
+    private static final int P28 = 1 << 28;
+    private static final long P34 = 1L << 34;
+    private static final long P35 = 1L << 35;
+    private static final long P41 = 1L << 41;
+    private static final long P42 = 1L << 42;
+    private static final long P48 = 1L << 48;
+    private static final long P49 = 1L << 49;
+    private static final long P55 = 1L << 55;
+    private static final long P56 = 1L << 56;
+    private final byte[] data;
+    private int offset;
+    
+    public CompactBytesDataInput(byte[] data) {
+        this.data = data;
+        this.offset = 0;
+    }
+    
+    public CompactBytesDataInput(byte[] data, int offset) {
+        this.data = data;
+        this.offset = offset;
+    }
+    
+    @Override
+    public void close() {
+    }
+    
+    @Override
+    public boolean readBool() {
+        return this.readByte() != (byte)0;
+    }
+    
+    @Override
+    public byte readByte() {
+        return (byte)(data[offset++]);
+    }
+    
+    @Override
+    public int readSByte() {
+        return data[offset++];
+    }
+    
+    @Override
+    public short readShort() {
+        int b0 = data[offset++] & 0xFF;
+        int b1 = data[offset++] & 0xFF;
+        return (short)(b0 << 8 | b1);
+    }
+    
+    @Override
+    public int readUShort() {
+        return this.readShort();
+    }
+    
+    @Override
+    public int readInt() {
+        int b0 = data[offset++] & 0xFF;
+        int b1 = data[offset++] & 0xFF;
+        int b2 = data[offset++] & 0xFF;
+        int b3 = data[offset++] & 0xFF;
+        return b0 << 24 | b1 << 16 | b2 << 8 | b3;
+    }
+    
+    @Override
+    public int readUInt() {
+        return this.readInt();
+    }
+    
+    @Override
+    public long readLong() {
+        long i0 = (long)(this.readUInt());
+        long i1 = (long)(this.readUInt());
+        return i0 << 32 | i1;
+    }
+    
+    @Override
+    public long readULong() {
+        return this.readLong();
+    }
+    
+    @Override
+    public int readVarInt() {
+        int value = this.readVarUInt();
+        return Integer.compareUnsigned(value & 1, 0) == 0 ? value >>> 1 : -((value >>> 1) + 1);
+    }
+    
+    @Override
+    public int readVarUInt() {
+        int value = data[offset++] & 0xFF;
+        if (Integer.compareUnsigned(value & CompactBytesDataInput.P7, 0) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P7 - 1 | (data[offset++] & 0xFF) << 7;
+        if (Integer.compareUnsigned(value & CompactBytesDataInput.P14, 0) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P14 - 1 | (data[offset++] & 0xFF) << 14;
+        if (Integer.compareUnsigned(value & CompactBytesDataInput.P21, 0) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P21 - 1 | (data[offset++] & 0xFF) << 21;
+        if (Integer.compareUnsigned(value & CompactBytesDataInput.P28, 0) == 0)
+            return value;
+        return value & CompactBytesDataInput.P28 - 1 | (data[offset++] & 0xFF) << 28;
+    }
+    
+    @Override
+    public long readVarLong() {
+        long value = this.readVarULong();
+        return Long.compareUnsigned(value & 1L, 0L) == 0 ? value >>> 1 : -((value >>> 1) + 1L);
+    }
+    
+    @Override
+    public long readVarULong() {
+        long value = data[offset++] & 0xFFL;
+        if (Long.compareUnsigned(value & (CompactBytesDataInput.P7 & 0xFFFFFFFFL), 0L) == 0)
+            return value;
+        value = value & (CompactBytesDataInput.P7 - 1 & 0xFFFFFFFFL) | (data[offset++] & 0xFFL) << 7;
+        if (Long.compareUnsigned(value & (CompactBytesDataInput.P14 & 0xFFFFFFFFL), 0L) == 0)
+            return value;
+        value = value & (CompactBytesDataInput.P14 - 1 & 0xFFFFFFFFL) | (data[offset++] & 0xFFL) << 14;
+        if (Long.compareUnsigned(value & (CompactBytesDataInput.P21 & 0xFFFFFFFFL), 0L) == 0)
+            return value;
+        value = value & (CompactBytesDataInput.P21 - 1 & 0xFFFFFFFFL) | (data[offset++] & 0xFFL) << 21;
+        if (Long.compareUnsigned(value & (CompactBytesDataInput.P28 & 0xFFFFFFFFL), 0L) == 0)
+            return value;
+        value = value & (CompactBytesDataInput.P28 - 1 & 0xFFFFFFFFL) | (data[offset++] & 0xFFL) << 28;
+        if (Long.compareUnsigned(value & CompactBytesDataInput.P35, 0L) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P35 - 1L | (data[offset++] & 0xFFL) << 35;
+        if (Long.compareUnsigned(value & CompactBytesDataInput.P42, 0L) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P42 - 1L | (data[offset++] & 0xFFL) << 42;
+        if (Long.compareUnsigned(value & CompactBytesDataInput.P49, 0L) == 0)
+            return value;
+        value = value & CompactBytesDataInput.P49 - 1L | (data[offset++] & 0xFFL) << 49;
+        if (Long.compareUnsigned(value & CompactBytesDataInput.P56, 0L) == 0)
+            return value;
+        return value & CompactBytesDataInput.P56 - 1L | (data[offset++] & 0xFFL) << 56;
+    }
+    
+    @Override
+    public float readFloat() {
+        return Float.intBitsToFloat(this.readUInt());
+    }
+    
+    @Override
+    public double readDouble() {
+        return Double.longBitsToDouble(this.readULong());
+    }
+    
+    @Override
+    public char readChar() {
+        return (char)(this.readVarUInt());
+    }
+    
+    @Override
+    public String readString() {
+        return new String(this.readBytes(), StandardCharsets.UTF_8);
+    }
+    
+    @Override
+    public byte[] readBytes() {
+        int size = this.readVarUInt();
+        return this.readRawBytes(size);
+    }
+    
+    @Override
+    public byte[] readRawBytes(int size) {
+        byte[] result = Arrays.copyOfRange(data, offset, offset + size);
+        this.offset = offset + size;
+        return result;
+    }
+    
+    @Override
+    public boolean[] readBoolArray() {
+        int size = this.readVarUInt();
+        boolean[] result = new boolean[size];
+        int limitForI = (size + 7) / 8;
+        for (int i = 0; i < limitForI; i++) {
+            byte bvalue = this.readByte();
+            int remainingBits = result.length - 8 * i;
+            if (remainingBits > 0)
+                result[i * 8 + 0] = (bvalue & (byte)1) > (byte)0;
+            if (remainingBits > 1)
+                result[i * 8 + 2] = (bvalue & (byte)4) > (byte)0;
+            if (remainingBits > 3)
+                result[i * 8 + 3] = (bvalue & (byte)8) > (byte)0;
+            if (remainingBits > 4)
+                result[i * 8 + 4] = (bvalue & (byte)16) > (byte)0;
+            if (remainingBits > 5)
+                result[i * 8 + 5] = (bvalue & (byte)32) > (byte)0;
+            if (remainingBits > 6)
+                result[i * 8 + 6] = (bvalue & (byte)64) > (byte)0;
+            if (remainingBits > 7)
+                result[i * 8 + 7] = (bvalue & (byte)-128) > (byte)0;
+        }
+        return result;
+    }
+    
+    @Override
+    public byte[] readByteArray() {
+        return this.readBytes();
+    }
+    
+    @Override
+    public byte[] readSByteArray() {
+        return this.readBytes();
+    }
+    
+    @Override
+    public short[] readShortArray() {
+        return this.readShortArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public short[] readShortArrayRaw(int length) {
+        short[] result = new short[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readShort();
+        return result;
+    }
+    
+    @Override
+    public short[] readUShortArray() {
+        return this.readShortArray();
+    }
+    
+    @Override
+    public short[] readUShortArrayRaw(int length) {
+        return this.readShortArrayRaw(length);
+    }
+    
+    @Override
+    public int[] readVarIntArray() {
+        return this.readVarIntArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public int[] readVarIntArrayRaw(int length) {
+        int[] result = new int[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readVarInt();
+        return result;
+    }
+    
+    @Override
+    public int[] readVarUIntArray() {
+        return this.readVarUIntArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public int[] readVarUIntArrayRaw(int length) {
+        int[] result = new int[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readVarUInt();
+        return result;
+    }
+    
+    @Override
+    public int[] readIntArray() {
+        return this.readIntArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public int[] readIntArrayRaw(int length) {
+        int[] result = new int[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readInt();
+        return result;
+    }
+    
+    @Override
+    public int[] readUIntArray() {
+        return this.readUIntArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public int[] readUIntArrayRaw(int length) {
+        int[] result = new int[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readUInt();
+        return result;
+    }
+    
+    @Override
+    public long[] readVarLongArray() {
+        return this.readVarLongArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public long[] readVarLongArrayRaw(int length) {
+        long[] result = new long[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readVarLong();
+        return result;
+    }
+    
+    @Override
+    public long[] readVarULongArray() {
+        return this.readVarULongArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public long[] readVarULongArrayRaw(int length) {
+        long[] result = new long[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readVarULong();
+        return result;
+    }
+    
+    @Override
+    public long[] readLongArray() {
+        return this.readLongArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public long[] readLongArrayRaw(int length) {
+        long[] result = new long[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readLong();
+        return result;
+    }
+    
+    @Override
+    public long[] readULongArray() {
+        return this.readLongArray();
+    }
+    
+    @Override
+    public long[] readULongArrayRaw(int length) {
+        return this.readLongArrayRaw(length);
+    }
+    
+    @Override
+    public float[] readFloatArray() {
+        return this.readFloatArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public float[] readFloatArrayRaw(int length) {
+        float[] result = new float[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readFloat();
+        return result;
+    }
+    
+    @Override
+    public double[] readDoubleArray() {
+        return this.readDoubleArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public double[] readDoubleArrayRaw(int length) {
+        double[] result = new double[length];
+        int limitForI = length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readDouble();
+        return result;
+    }
+    
+    @Override
+    public String[] readStringArray() {
+        return this.readStringArrayRaw(this.readVarUInt());
+    }
+    
+    @Override
+    public String[] readStringArrayRaw(int length) {
+        String[] result = new String[length];
+        int limitForI = result.length;
+        for (int i = 0; i < limitForI; i++)
+            result[i] = this.readString();
+        return result;
+    }
+    
+    @Override
+    public void skip(int bytes) {
+        this.offset = offset + bytes;
+    }
+    
+    @Override
+    public boolean hasMore() {
+        return offset < data.length;
+    }
+    
+    public int getOffset() {
+        return offset;
+    }
+}

Shared/src/main/java/compactio/CompactBytesDataOutput.java

+package compactio;
+
+import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
+
+public final class CompactBytesDataOutput implements CompactDataOutput, AutoCloseable {
+    private static final int P6 = 1 << 6;
+    private static final int P7 = 1 << 7;
+    private static final int P13 = 1 << 13;
+    private static final int P14 = 1 << 14;
+    private static final int P20 = 1 << 20;
+    private static final int P21 = 1 << 21;
+    private static final int P27 = 1 << 27;
+    private static final int P28 = 1 << 28;
+    private static final long P34 = 1L << 34;
+    private static final long P35 = 1L << 35;
+    private static final long P41 = 1L << 41;
+    private static final long P42 = 1L << 42;
+    private static final long P48 = 1L << 48;
+    private static final long P49 = 1L << 49;
+    private static final long P55 = 1L << 55;
+    private static final long P56 = 1L << 56;
+    private byte[] data = new byte[16];
+    private int length = 0;
+    
+    private void reserve(int bytes) {
+        while (length + bytes > data.length)
+            this.data = Arrays.copyOf(data, 2 * data.length);
+    }
+    
+    public byte[] asByteArray() {
+        return Arrays.copyOf(data, length);
+    }
+    
+    @Override
+    public void close() {
+    }
+    
+    @Override
+    public void writeBool(boolean value) {
+        this.writeByte(value ? 1 : 0);
+    }
+    
+    @Override
+    public void writeByte(int value) {
+        this.reserve(1);
+        data[length++] = (byte)value;
+    }
+    
+    @Override
+    public void writeSByte(byte value) {
+        this.writeByte(value);
+    }
+    
+    @Override
+    public void writeShort(short value) {
+        this.writeUShort(value);
+    }
+    
+    @Override
+    public void writeUShort(int value) {
+        this.reserve(2);
+        data[length++] = (byte)(value >> 8);
+        data[length++] = (byte)value;
+    }
+    
+    @Override
+    public void writeInt(int value) {
+        this.writeUInt(value);
+    }
+    
+    @Override
+    public void writeUInt(int value) {
+        this.reserve(4);
+        data[length++] = (byte)(value >>> 24);
+        data[length++] = (byte)(value >>> 16);
+        data[length++] = (byte)(value >>> 8);
+        data[length++] = (byte)value;
+    }
+    
+    @Override
+    public void writeLong(long value) {
+        this.writeULong(value);
+    }
+    
+    @Override
+    public void writeULong(long value) {
+        this.reserve(8);
+        data[length++] = (byte)(value >>> 56);
+        data[length++] = (byte)(value >>> 48);
+        data[length++] = (byte)(value >>> 40);
+        data[length++] = (byte)(value >>> 32);
+        data[length++] = (byte)(value >>> 24);
+        data[length++] = (byte)(value >>> 16);
+        data[length++] = (byte)(value >>> 8);
+        data[length++] = (byte)value;
+    }
+    
+    @Override
+    public void writeVarInt(int value) {
+        this.writeVarUInt(value < 0 ? (1 - value << 1) + 1 : value << 1);
+    }
+    
+    @Override
+    public void writeVarUInt(int value) {
+        this.reserve(5);
+        if (Integer.compareUnsigned(value, CompactBytesDataOutput.P7) < 0) {
+            data[length++] = (byte)(value & 127);
+        }
+        else
+            if (Integer.compareUnsigned(value, CompactBytesDataOutput.P14) < 0) {
+                data[length++] = (byte)(value & 127 | 128);
+                data[length++] = (byte)(value >>> 7 & 127);
+            }
+            else
+                if (Integer.compareUnsigned(value, CompactBytesDataOutput.P21) < 0) {
+                    data[length++] = (byte)(value & 127 | 128);
+                    data[length++] = (byte)(value >>> 7 & 127 | 128);
+                    data[length++] = (byte)(value >>> 14 & 127);
+                }
+                else
+                    if (Integer.compareUnsigned(value, CompactBytesDataOutput.P28) < 0) {
+                        data[length++] = (byte)(value & 127 | 128);
+                        data[length++] = (byte)(value >>> 7 & 127 | 128);
+                        data[length++] = (byte)(value >>> 14 & 127 | 128);
+                        data[length++] = (byte)(value >>> 21 & 127);
+                    }
+                    else {
+                        data[length++] = (byte)(value & 127 | 128);
+                        data[length++] = (byte)(value >>> 7 & 127 | 128);
+                        data[length++] = (byte)(value >>> 14 & 127 | 128);
+                        data[length++] = (byte)(value >>> 21 & 127 | 128);
+                        data[length++] = (byte)(value >>> 28 & 127);
+                    }
+    }
+    
+    @Override
+    public void writeVarLong(long value) {
+        this.writeVarULong(value < 0L ? (1L - value << 1) + 1L : value << 1);
+    }
+    
+    @Override
+    public void writeVarULong(long value) {
+        this.reserve(9);
+        if (Long.compareUnsigned(value, CompactBytesDataOutput.P7) < 0) {
+            data[length++] = (byte)(value & 127L);
+        }
+        else
+            if (Long.compareUnsigned(value, CompactBytesDataOutput.P14) < 0) {
+                data[length++] = (byte)(value & 127L | 128L);
+                data[length++] = (byte)(value >>> 7 & 127L);
+            }
+            else
+                if (Long.compareUnsigned(value, CompactBytesDataOutput.P21) < 0) {
+                    data[length++] = (byte)(value & 127L | 128L);
+                    data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                    data[length++] = (byte)(value >>> 14 & 127L);
+                }
+                else
+                    if (Long.compareUnsigned(value, CompactBytesDataOutput.P28) < 0) {
+                        data[length++] = (byte)(value & 127L | 128L);
+                        data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                        data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                        data[length++] = (byte)(value >>> 21 & 127L);
+                    }
+                    else
+                        if (Long.compareUnsigned(value, CompactBytesDataOutput.P35) < 0) {
+                            data[length++] = (byte)(value & 127L | 128L);
+                            data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                            data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                            data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                            data[length++] = (byte)(value >>> 28 & 127L);
+                        }
+                        else
+                            if (Long.compareUnsigned(value, CompactBytesDataOutput.P42) < 0) {
+                                data[length++] = (byte)(value & 127L | 128L);
+                                data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                                data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                                data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                                data[length++] = (byte)(value >>> 28 & 127L | 128L);
+                                data[length++] = (byte)(value >>> 35 & 127L);
+                            }
+                            else
+                                if (Long.compareUnsigned(value, CompactBytesDataOutput.P49) < 0) {
+                                    data[length++] = (byte)(value & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 28 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 35 & 127L | 128L);
+                                    data[length++] = (byte)(value >>> 42 & 127L);
+                                }
+                                else
+                                    if (Long.compareUnsigned(value, CompactBytesDataOutput.P56) < 0) {
+                                        data[length++] = (byte)(value & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 28 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 35 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 42 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 49 & 127L);
+                                    }
+                                    else {
+                                        data[length++] = (byte)(value & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 7 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 14 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 21 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 28 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 35 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 42 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 49 & 127L | 128L);
+                                        data[length++] = (byte)(value >>> 56);
+                                    }
+    }
+    
+    @Override
+    public void writeFloat(float value) {
+        this.writeUInt(Float.floatToRawIntBits(value));
+    }
+    
+    @Override
+    public void writeDouble(double value) {
+        this.writeULong(Double.doubleToRawLongBits(value));
+    }
+    
+    @Override
+    public void writeChar(char value) {
+        this.writeVarUInt(value);
+    }
+    
+    @Override
+    public void writeBytes(byte[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeRawBytes(data);
+    }
+    
+    @Override
+    public void writeBytes(byte[] data, int offset, int length) {
+        if (!(Integer.compareUnsigned(length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(length);
+        this.writeRawBytes(data, offset, length);
+    }
+    
+    @Override
+    public void writeString(String str) {
+        this.writeBytes(str.getBytes(StandardCharsets.UTF_8));
+    }
+    
+    @Override
+    public void writeRawBytes(byte[] value) {
+        this.reserve(value.length);
+        System.arraycopy(value, 0, data, length, value.length);
+        this.length = length + value.length;
+    }
+    
+    @Override
+    public void writeRawBytes(byte[] value, int offset, int length) {
+        this.reserve(value.length);
+        System.arraycopy(value, offset, data, this.length, value.length);
+        this.length = this.length + length;
+    }
+    
+    @Override
+    public void writeBoolArray(boolean[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        int i = 0;
+        while (i < data.length - 7) {
+            int bvalue = 0;
+            if (data[i + 0])
+                bvalue = bvalue | 1;
+            if (data[i + 1])
+                bvalue = bvalue | 2;
+            if (data[i + 2])
+                bvalue = bvalue + 4;
+            if (data[i + 3])
+                bvalue = bvalue + 8;
+            if (data[i + 4])
+                bvalue = bvalue + 16;
+            if (data[i + 5])
+                bvalue = bvalue + 32;
+            if (data[i + 6])
+                bvalue = bvalue + 64;
+            if (data[i + 7])
+                bvalue = bvalue + 128;
+            this.writeByte(bvalue);
+            i = i + 8;
+        }
+        if (i < data.length) {
+            int bvalue = 0;
+            int limitForOffset = data.length % 7;
+            for (int offset = 0; offset < limitForOffset; offset++)
+                if (data[i + offset])
+                    bvalue = bvalue + (1 << i);
+            this.writeByte(bvalue);
+        }
+    }
+    
+    @Override
+    public void writeByteArray(byte[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeBytes(data);
+    }
+    
+    @Override
+    public void writeSByteArray(byte[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeBytes(data);
+    }
+    
+    @Override
+    public void writeShortArray(short[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeShortArrayRaw(data);
+    }
+    
+    @Override
+    public void writeShortArrayRaw(short[] data) {
+        for (short element : data)
+            this.writeShort(element);
+    }
+    
+    @Override
+    public void writeUShortArray(short[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeShortArray(data);
+    }
+    
+    @Override
+    public void writeUShortArrayRaw(short[] data) {
+        this.writeShortArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarIntArray(int[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeVarIntArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarIntArrayRaw(int[] data) {
+        for (int element : data)
+            this.writeVarInt(element);
+    }
+    
+    @Override
+    public void writeVarUIntArray(int[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeVarUIntArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarUIntArrayRaw(int[] data) {
+        for (int element : data)
+            this.writeVarUInt(element);
+    }
+    
+    @Override
+    public void writeIntArray(int[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeIntArrayRaw(data);
+    }
+    
+    @Override
+    public void writeIntArrayRaw(int[] data) {
+        for (int element : data)
+            this.writeInt(element);
+    }
+    
+    @Override
+    public void writeUIntArray(int[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeIntArray(data);
+    }
+    
+    @Override
+    public void writeUIntArrayRaw(int[] data) {
+        this.writeIntArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarLongArray(long[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeVarLongArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarLongArrayRaw(long[] data) {
+        for (long element : data)
+            this.writeVarLong(element);
+    }
+    
+    @Override
+    public void writeVarULongArray(long[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeVarULongArrayRaw(data);
+    }
+    
+    @Override
+    public void writeVarULongArrayRaw(long[] data) {
+        for (long element : data)
+            this.writeVarULong(element);
+    }
+    
+    @Override
+    public void writeLongArray(long[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeLongArrayRaw(data);
+    }
+    
+    @Override
+    public void writeLongArrayRaw(long[] data) {
+        for (long element : data)
+            this.writeLong(element);
+    }
+    
+    @Override
+    public void writeULongArray(long[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeLongArray(data);
+    }
+    
+    @Override
+    public void writeULongArrayRaw(long[] data) {
+        this.writeLongArrayRaw(data);
+    }
+    
+    @Override
+    public void writeFloatArray(float[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeFloatArrayRaw(data);
+    }
+    
+    @Override
+    public void writeFloatArrayRaw(float[] data) {
+        for (float element : data)
+            this.writeFloat(element);
+    }
+    
+    @Override
+    public void writeDoubleArray(double[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeDoubleArrayRaw(data);
+    }
+    
+    @Override
+    public void writeDoubleArrayRaw(double[] data) {
+        for (double element : data)
+            this.writeDouble(element);
+    }
+    
+    @Override
+    public void writeStringArray(String[] data) {
+        if (!(Integer.compareUnsigned(data.length, -1) < 0))
+            throw new AssertionError("Array length cannot exceed uint limit");
+        this.writeVarUInt(data.length);
+        this.writeStringArrayRaw(data);
+    }
+    
+    @Override
+    public void writeStringArrayRaw(String[] data) {
+        for (String element : data)
+            this.writeString(element);
+    }
+    
+    @Override
+    public void flush() {
+    }
+}

Shared/src/main/java/compactio/CompactDataInput.java

+package compactio;
+
+public interface CompactDataInput extends AutoCloseable {
+    boolean readBool();
+    
+    byte readByte();
+    
+    int readSByte();
+    
+    short readShort();
+    
+    int readUShort();
+    
+    int readInt();
+    
+    int readUInt();
+    
+    long readLong();
+    
+    long readULong();
+    
+    int readVarInt();
+    
+    int readVarUInt();
+    
+    long readVarLong();
+    
+    long readVarULong();
+    
+    float readFloat();
+    
+    double readDouble();
+    
+    char readChar();
+    
+    String readString();
+    
+    byte[] readBytes();
+    
+    byte[] readRawBytes(int length);
+    
+    boolean[] readBoolArray();
+    
+    byte[] readByteArray();
+    
+    byte[] readSByteArray();
+    
+    short[] readShortArray();
+    
+    short[] readShortArrayRaw(int length);
+    
+    short[] readUShortArray();
+    
+    short[] readUShortArrayRaw(int length);
+    
+    int[] readVarIntArray();
+    
+    int[] readVarIntArrayRaw(int length);
+    
+    int[] readVarUIntArray();
+    
+    int[] readVarUIntArrayRaw(int length);
+    
+    int[] readIntArray();
+    
+    int[] readIntArrayRaw(int length);
+    
+    int[] readUIntArray();
+    
+    int[] readUIntArrayRaw(int length);
+    
+    long[] readVarLongArray();
+    
+    long[] readVarLongArrayRaw(int length);
+    
+    long[] readVarULongArray();
+    
+    long[] readVarULongArrayRaw(int length);
+    
+    long[] readLongArray();
+    
+    long[] readLongArrayRaw(int length);
+    
+    long[] readULongArray();
+    
+    long[] readULongArrayRaw(int length);
+    
+    float[] readFloatArray();
+    
+    float[] readFloatArrayRaw(int length);
+    
+    double[] readDoubleArray();
+    
+    double[] readDoubleArrayRaw(int length);
+    
+    String[] readStringArray();
+    
+    String[] readStringArrayRaw(int length);
+    
+    void skip(int bytes);
+    
+    boolean hasMore();
+    
+    @Override
+    public void close();
+}

Shared/src/main/java/compactio/CompactDataOutput.java

+package compactio;
+
+public interface CompactDataOutput extends AutoCloseable {
+    void writeBool(boolean value);
+    
+    void writeByte(int value);
+    
+    void writeSByte(byte value);
+    
+    void writeShort(short value);
+    
+    void writeUShort(int value);
+    
+    void writeInt(int value);
+    
+    void writeUInt(int value);
+    
+    void writeLong(long value);
+    
+    void writeULong(long value);
+    
+    void writeVarInt(int value);
+    
+    void writeVarUInt(int value);
+    
+    void writeVarLong(long value);
+    
+    void writeVarULong(long value);
+    
+    void writeFloat(float value);
+    
+    void writeDouble(double value);
+    
+    void writeChar(char value);
+    
+    void writeString(String value);
+    
+    void writeBytes(byte[] data);
+    
+    void writeBytes(byte[] data, int offset, int length);
+    
+    void writeRawBytes(byte[] value);
+    
+    void writeRawBytes(byte[] value, int offset, int length);
+    
+    void writeBoolArray(boolean[] data);
+    
+    void writeByteArray(byte[] data);
+    
+    void writeSByteArray(byte[] data);
+    
+    void writeShortArray(short[] data);
+    
+    void writeShortArrayRaw(short[] data);
+    
+    void writeUShortArray(short[] data);
+    
+    void writeUShortArrayRaw(short[] data);
+    
+    void writeVarIntArray(int[] data);
+    
+    void writeVarIntArrayRaw(int[] data);
+    
+    void writeVarUIntArray(int[] data);
+    
+    void writeVarUIntArrayRaw(int[] data);
+    
+    void writeIntArray(int[] data);
+    
+    void writeIntArrayRaw(int[] data);
+    
+    void writeUIntArray(int[] data);
+    
+    void writeUIntArrayRaw(int[] data);
+    
+    void writeVarLongArray(long[] data);
+    
+    void writeVarLongArrayRaw(long[] data);
+    
+    void writeVarULongArray(long[] data);
+    
+    void writeVarULongArrayRaw(long[] data);
+    
+    void writeLongArray(long[] data);
+    
+    void writeLongArrayRaw(long[] data);
+    
+    void writeULongArray(long[] data);
+    
+    void writeULongArrayRaw(long[] data);
+    
+    void writeFloatArray(float[] data);
+    
+    void writeFloatArrayRaw(float[] data);
+    
+    void writeDoubleArray(double[] data);
+    
+    void writeDoubleArrayRaw(double[] data);
+    
+    void writeStringArray(String[] data);
+    
+    void writeStringArrayRaw(String[] data);
+    
+    void flush();
+    
+    @Override
+    public void close();
+}

Shared/src/main/java/zsynthetic/FunctionUSizeTToBool.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionUSizeTToBool<T> {
+    boolean invoke(int index, T value);
+}

Shared/src/main/java/zsynthetic/FunctionUSizeTToU.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionUSizeTToU<U, T> {
+    U invoke(int index, T value);
+}

Shared/src/main/java/zsynthetic/FunctionUSizeTToVoid.java

+package zsynthetic;
+
+@FunctionalInterface
+public interface FunctionUSizeTToVoid<T> {
+    void invoke(int index, T value);
+}

Validator/src/main/java/org/openzen/zenscript/validator/visitors/ValidationUtils.java

 import org.openzen.zenscript.codemodel.FunctionParameter;
 import org.openzen.zenscript.codemodel.HighLevelDefinition;
 import org.openzen.zenscript.codemodel.Modifiers;
-import org.openzen.zenscript.codemodel.generic.GenericParameterBound;
+import org.openzen.zenscript.codemodel.generic.TypeParameterBound;
 import org.openzen.zenscript.codemodel.generic.GenericParameterBoundVisitor;
 import org.openzen.zenscript.codemodel.generic.ParameterSuperBound;
 import org.openzen.zenscript.codemodel.generic.ParameterTypeBound;
 		
 		for (int i = 0; i < typeParameters.length; i++) {
 			TypeParameter typeParameter = typeParameters[i];
-			for (GenericParameterBound bound : typeParameter.bounds) {
+			for (TypeParameterBound bound : typeParameter.bounds) {
 				// TODO - obtain member cache for validation
 				/*if (!bound.matches(typeArguments[i])) {
 					target.logError(