- Fix missing shift operators in some integer types

- Fix some problems when comparing a long with an int or ulong with uint
- Add signed-unsigned implicit array conversion (sbyte[] <-> byte[], short[] <-> ushort[], int[] <-> uint[], long[] <-> ulong[])
- Fix bug when copying multiple lines from the source editor
- Added string <-> byte[] conversion operations
- Fix unsigned arrays, use compact representations
- Added suffixes & custom suffixes
- Added 0x 0b 0o for hex, binary and octal notation

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

 		
 		return false;
 	}
+
+	public boolean accepts(int arguments) {
+		return arguments >= this.minParameters && arguments <= this.maxParameters;
+	}
 }

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

 	BYTE_AND_BYTE,
 	BYTE_OR_BYTE,
 	BYTE_XOR_BYTE,
+	BYTE_SHL,
+	BYTE_SHR,
 	BYTE_COMPARE,
 	BYTE_TO_SBYTE,
 	BYTE_TO_SHORT,
 	SBYTE_AND_SBYTE,
 	SBYTE_OR_SBYTE,
 	SBYTE_XOR_SBYTE,
+	SBYTE_SHL,
+	SBYTE_SHR,
+	SBYTE_USHR,
 	SBYTE_COMPARE,
 	SBYTE_TO_BYTE,
 	SBYTE_TO_SHORT,
 	SHORT_AND_SHORT,
 	SHORT_OR_SHORT,
 	SHORT_XOR_SHORT,
+	SHORT_SHL,
+	SHORT_SHR,
+	SHORT_USHR,
 	SHORT_COMPARE,
 	SHORT_TO_BYTE,
 	SHORT_TO_SBYTE,
 	USHORT_AND_USHORT,
 	USHORT_OR_USHORT,
 	USHORT_XOR_USHORT,
+	USHORT_SHL,
+	USHORT_SHR,
 	USHORT_COMPARE,
 	USHORT_TO_BYTE,
 	USHORT_TO_SBYTE,
 	LONG_SHR,
 	LONG_USHR,
 	LONG_COMPARE,
+	LONG_COMPARE_INT,
 	LONG_TO_BYTE,
 	LONG_TO_SBYTE,
 	LONG_TO_SHORT,
 	ULONG_SHL,
 	ULONG_SHR,
 	ULONG_COMPARE,
+	ULONG_COMPARE_UINT,
+	ULONG_COMPARE_USIZE,
 	ULONG_TO_BYTE,
 	ULONG_TO_SBYTE,
 	ULONG_TO_SHORT,
 	USIZE_SHL,
 	USIZE_SHR,
 	USIZE_COMPARE,
+	USIZE_COMPARE_UINT,
 	USIZE_TO_BYTE,
 	USIZE_TO_SBYTE,
 	USIZE_TO_SHORT,
 	ARRAY_SAME,
 	ARRAY_NOTSAME,
 	
+	SBYTE_ARRAY_AS_BYTE_ARRAY,
+	BYTE_ARRAY_AS_SBYTE_ARRAY,
+	SHORT_ARRAY_AS_USHORT_ARRAY,
+	USHORT_ARRAY_AS_SHORT_ARRAY,
+	INT_ARRAY_AS_UINT_ARRAY,
+	UINT_ARRAY_AS_INT_ARRAY,
+	LONG_ARRAY_AS_ULONG_ARRAY,
+	ULONG_ARRAY_AS_LONG_ARRAY,
+	
 	FUNCTION_CALL,
 	FUNCTION_SAME,
 	FUNCTION_NOTSAME,

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

 		return false;
 	}
 	
+	public FunctionalMemberRef getStaticMethod(int arguments, ITypeID returnType) {
+		for (TypeMember<FunctionalMemberRef> method : methods) {
+			if (method.member.isStatic() && method.member.getHeader().accepts(arguments) && method.member.getHeader().getReturnType() == returnType)
+				return method.member;
+		}
+		
+		return null;
+	}
+	
 	public List<TypeMember<FunctionalMemberRef>> getMethodMembers() {
 		return this.methods;
 	}

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

 					OperatorType.INDEXGET,
 					sliceHeader,
 					ARRAY_INDEXGETRANGE);
+			
+			if (baseType == BYTE)
+				castImplicit(definition, BYTE_ARRAY_AS_SBYTE_ARRAY, registry.getArray(SBYTE, 1));
+			if (baseType == SBYTE)
+				castImplicit(definition, SBYTE_ARRAY_AS_BYTE_ARRAY, registry.getArray(BYTE, 1));
+			if (baseType == SHORT)
+				castImplicit(definition, SHORT_ARRAY_AS_USHORT_ARRAY, registry.getArray(USHORT, 1));
+			if (baseType == USHORT)
+				castImplicit(definition, USHORT_ARRAY_AS_SHORT_ARRAY, registry.getArray(SHORT, 1));
+			if (baseType == INT)
+				castImplicit(definition, INT_ARRAY_AS_UINT_ARRAY, registry.getArray(UINT, 1));
+			if (baseType == UINT)
+				castImplicit(definition, UINT_ARRAY_AS_INT_ARRAY, registry.getArray(INT, 1));
+			if (baseType == LONG)
+				castImplicit(definition, LONG_ARRAY_AS_ULONG_ARRAY, registry.getArray(ULONG, 1));
+			if (baseType == ULONG)
+				castImplicit(definition, ULONG_ARRAY_AS_LONG_ARRAY, registry.getArray(LONG, 1));
 		}
 
 		FunctionHeader containsHeader = new FunctionHeader(BOOL, new FunctionParameter(baseType, "value"));
 		and(builtin, BYTE_AND_BYTE, BYTE, BYTE);
 		or(builtin, BYTE_OR_BYTE, BYTE, BYTE);
 		xor(builtin, BYTE_XOR_BYTE, BYTE, BYTE);
+		shl(builtin, BYTE_SHL, USIZE, BYTE);
+		shr(builtin, BYTE_SHR, USIZE, BYTE);
 		compare(builtin, BYTE_COMPARE, BYTE);
 		
 		castImplicit(builtin, BYTE_TO_SBYTE, SBYTE);
 		and(builtin, SBYTE_AND_SBYTE, SBYTE, SBYTE);
 		or(builtin, SBYTE_OR_SBYTE, SBYTE, SBYTE);
 		xor(builtin, SBYTE_XOR_SBYTE, SBYTE, SBYTE);
+		shl(builtin, SBYTE_SHL, USIZE, SBYTE);
+		shr(builtin, SBYTE_SHR, USIZE, SBYTE);
+		ushr(builtin, SBYTE_USHR, USIZE, SBYTE);
 		compare(builtin, SBYTE_COMPARE, SBYTE);
 		
 		castImplicit(builtin, SBYTE_TO_BYTE, BYTE);
 		and(builtin, SHORT_AND_SHORT, SHORT, SHORT);
 		or(builtin, SHORT_OR_SHORT, SHORT, SHORT);
 		xor(builtin, SHORT_XOR_SHORT, SHORT, SHORT);
+		shl(builtin, SHORT_SHL, USIZE, SHORT);
+		shr(builtin, SHORT_SHR, USIZE, SHORT);
+		ushr(builtin, SHORT_USHR, USIZE, SHORT);
 		compare(builtin, SHORT_COMPARE, SHORT);
 		
 		castExplicit(builtin, SHORT_TO_BYTE, BYTE);
 		and(builtin, USHORT_AND_USHORT, USHORT, USHORT);
 		or(builtin, USHORT_OR_USHORT, USHORT, USHORT);
 		xor(builtin, USHORT_XOR_USHORT, USHORT, USHORT);
+		shl(builtin, USHORT_SHL, USIZE, USHORT);
+		shr(builtin, USHORT_SHR, USIZE, USHORT);
 		compare(builtin, USHORT_COMPARE, USHORT);
 		
 		castExplicit(builtin, USHORT_TO_BYTE, BYTE);
 		xor(builtin, INT_XOR_INT, INT, INT);
 		xor(builtin, LONG_XOR_LONG, LONG, LONG, INT_TO_LONG);
 		
-		shl(builtin, INT_SHL, INT, INT);
-		shr(builtin, INT_SHR, INT, INT);
-		ushr(builtin, INT_USHR, INT, INT);
+		shl(builtin, INT_SHL, USIZE, INT);
+		shr(builtin, INT_SHR, USIZE, INT);
+		ushr(builtin, INT_USHR, USIZE, INT);
 		
 		compare(builtin, INT_COMPARE, INT);
 		compare(builtin, LONG_COMPARE, LONG, INT_TO_LONG);
 		xor(builtin, UINT_XOR_UINT, UINT, UINT);
 		xor(builtin, ULONG_XOR_ULONG, ULONG, ULONG, UINT_TO_ULONG);
 		
-		shl(builtin, UINT_SHL, UINT, UINT);
-		shr(builtin, UINT_SHR, UINT, UINT);
+		shl(builtin, UINT_SHL, USIZE, UINT);
+		shr(builtin, UINT_SHR, USIZE, UINT);
 		
 		compare(builtin, UINT_COMPARE, UINT);
 		compare(builtin, ULONG_COMPARE, ULONG, UINT_TO_LONG);
 		and(builtin, LONG_AND_LONG, LONG, LONG);
 		xor(builtin, LONG_XOR_LONG, LONG, LONG);
 		
-		shl(builtin, LONG_SHL, INT, LONG);
-		shr(builtin, LONG_SHR, INT, LONG);
-		ushr(builtin, LONG_USHR, INT, LONG);
+		shl(builtin, LONG_SHL, USIZE, LONG);
+		shr(builtin, LONG_SHR, USIZE, LONG);
+		ushr(builtin, LONG_USHR, USIZE, LONG);
 		
+		compare(builtin, LONG_COMPARE_INT, INT);
 		compare(builtin, LONG_COMPARE, LONG);
 		compare(builtin, FLOAT_COMPARE, FLOAT, LONG_TO_FLOAT);
 		compare(builtin, DOUBLE_COMPARE, DOUBLE, LONG_TO_DOUBLE);
 		and(builtin, ULONG_AND_ULONG, ULONG, ULONG);
 		xor(builtin, ULONG_XOR_ULONG, ULONG, ULONG);
 		
-		shl(builtin, ULONG_SHL, INT, ULONG);
-		shr(builtin, ULONG_SHR, INT, ULONG);
+		shl(builtin, ULONG_SHL, USIZE, ULONG);
+		shr(builtin, ULONG_SHR, USIZE, ULONG);
 		
+		compare(builtin, ULONG_COMPARE_UINT, UINT);
+		compare(builtin, ULONG_COMPARE_USIZE, USIZE);
 		compare(builtin, ULONG_COMPARE, ULONG);
 		compare(builtin, FLOAT_COMPARE, FLOAT, ULONG_TO_FLOAT);
 		compare(builtin, DOUBLE_COMPARE, DOUBLE, ULONG_TO_DOUBLE);
 		and(builtin, USIZE_AND_USIZE, USIZE, USIZE);
 		xor(builtin, USIZE_XOR_USIZE, USIZE, USIZE);
 		
-		shl(builtin, USIZE_SHL, INT, USIZE);
-		shr(builtin, USIZE_SHR, INT, USIZE);
+		shl(builtin, USIZE_SHL, USIZE, USIZE);
+		shr(builtin, USIZE_SHR, USIZE, USIZE);
 		
+		compare(builtin, USIZE_COMPARE_UINT, UINT);
 		compare(builtin, USIZE_COMPARE, USIZE);
 		compare(builtin, ULONG_COMPARE, ULONG, USIZE_TO_ULONG);
 		compare(builtin, FLOAT_COMPARE, FLOAT, USIZE_TO_FLOAT);
 		castExplicit(builtin, DOUBLE_TO_USHORT, USHORT);
 		castExplicit(builtin, DOUBLE_TO_INT, INT);
 		castExplicit(builtin, DOUBLE_TO_UINT, UINT);
-		castExplicit(builtin, DOUBLE_TO_ULONG, ULONG);
+		castExplicit(builtin, DOUBLE_TO_LONG, LONG);
 		castExplicit(builtin, DOUBLE_TO_ULONG, ULONG);
 		castExplicit(builtin, DOUBLE_TO_USIZE, USIZE);
 		castImplicit(builtin, DOUBLE_TO_FLOAT, FLOAT);
 		processType(builtin, STRING);
 	}
 	
-	private void castedTargetCall(OperatorMember member, BuiltinID casterBuiltin) {
-		CasterMemberRef caster = castImplicitRef(member.definition, casterBuiltin, member.header.parameters[0].type);
+	private void castedTargetCall(OperatorMember member, ITypeID toType, BuiltinID casterBuiltin) {
+		CasterMemberRef caster = castImplicitRef(member.definition, casterBuiltin, toType);
 		TranslatedOperatorMemberRef method = new TranslatedOperatorMemberRef(member, GenericMapper.EMPTY, call -> member.ref(null).call(call.position, caster.cast(call.position, call.target, true), call.arguments, call.scope));
 		members.getOrCreateGroup(member.operator).addMethod(method, TypeMemberPriority.SPECIFIED);
 	}
 	}
 	
 	private void add(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(addOp(definition, id, operand, result), caster);
+		castedTargetCall(addOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember subOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void sub(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(subOp(definition, id, operand, result), caster);
+		castedTargetCall(subOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember mulOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void mul(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(mulOp(definition, id, operand, result), caster);
+		castedTargetCall(mulOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember divOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void div(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(divOp(definition, id, operand, result), caster);
+		castedTargetCall(divOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember modOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void mod(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(modOp(definition, id, operand, result), caster);
+		castedTargetCall(modOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember shlOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void shl(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(shlOp(definition, id, operand, result), caster);
+		castedTargetCall(shlOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember shrOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void shr(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(shrOp(definition, id, operand, result), caster);
+		castedTargetCall(shrOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember ushrOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void ushr(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(ushrOp(definition, id, operand, result), caster);
+		castedTargetCall(ushrOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember orOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void and(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(andOp(definition, id, operand, result), caster);
+		castedTargetCall(andOp(definition, id, operand, result), result, caster);
 	}
 	
 	private OperatorMember xorOp(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void xor(HighLevelDefinition definition, BuiltinID id, ITypeID operand, ITypeID result, BuiltinID caster) {
-		castedTargetCall(xorOp(definition, id, operand, result), caster);
+		castedTargetCall(xorOp(definition, id, operand, result), result, caster);
 	}
 	
 	private void indexGet(HighLevelDefinition cls, BuiltinID id, ITypeID operand, ITypeID result) {
 	}
 	
 	private void compare(HighLevelDefinition definition, BuiltinID id, ITypeID operand, BuiltinID caster) {
-		castedTargetCall(compareOp(definition, id, operand), caster);
+		castedTargetCall(compareOp(definition, id, operand), operand, caster);
 	}
 	
 	private void getter(HighLevelDefinition cls, BuiltinID id, String name, ITypeID type) {

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/SourceEditor.java

 		String extract = tokens.extract(
 				SourcePosition.min(cursorStart, cursorEnd),
 				SourcePosition.max(cursorStart, cursorEnd));
+		if (context.getUIContext() == null)
+			throw new NullPointerException("No context!");
+		if (context.getUIContext().getClipboard() == null)
+			throw new NullPointerException("No clipboard!");
+		
 		context.getUIContext().getClipboard().copyAsString(extract);
 	}
 	
 					return IDENTIFIER;
 				case T_FLOAT:
 				case T_INT:
+				case T_PREFIXED_INT:
 					return NUMBER;
 				case T_STRING_SQ:
 				case T_STRING_DQ:

IDE/src/main/java/org/openzen/zenscript/ide/ui/view/editor/TokenModel.java

 			
 			for (int i = fromT.line + 1; i < toT.line; i++) {
 				result.append("\n");
-				for (ZSToken t : fromLine.getTokens()) {
+				for (ZSToken t : getLine(i).getTokens()) {
 					result.append(t.content);
 				}
 			}

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

 import org.openzen.zenscript.javashared.JavaVariantOption;
 
 public class JavaExpressionVisitor implements ExpressionVisitor<Void> {
-	private static final int PUBLIC = Opcodes.ACC_PUBLIC;
-	private static final int STATIC = Opcodes.ACC_STATIC;
-	private static final int PUBLIC_STATIC = PUBLIC | STATIC;
-
 	private static final JavaMethod BOOLEAN_PARSE = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "parseBoolean", "(Ljava/lang/String;)Z");
 	private static final JavaMethod BOOLEAN_TO_STRING = JavaMethod.getNativeStatic(JavaClass.BOOLEAN, "toString", "(Z)Ljava/lang/String;");
 	private static final JavaMethod BYTE_PARSE = JavaMethod.getNativeStatic(JavaClass.BYTE, "parseByte", "(Ljava/lang/String;)B");
 				case SHORT_COMPARE:
 				case INT_COMPARE:
 				case CHAR_COMPARE:
+				case USIZE_COMPARE:
 					expression.left.accept(this);
 					expression.right.accept(this);
 					compareInt(expression.comparison);
 					break;
 				case UINT_COMPARE:
+				case USIZE_COMPARE_UINT:
 					expression.left.accept(this);
 					expression.right.accept(this);
 					javaWriter.invokeStatic(INTEGER_COMPARE_UNSIGNED);
 					javaWriter.invokeStatic(LONG_COMPARE_UNSIGNED);
 					compareGeneric(expression.comparison);
 					break;
+				case ULONG_COMPARE_UINT:
+					expression.left.accept(this);
+					expression.right.accept(this);
+					javaWriter.i2l();
+					javaWriter.constant(0xFFFF_FFFFL);
+					javaWriter.lAnd();
+					javaWriter.invokeStatic(LONG_COMPARE_UNSIGNED);
+					compareGeneric(expression.comparison);
+					break;
+				case ULONG_COMPARE_USIZE:
+					expression.left.accept(this);
+					expression.right.accept(this);
+					javaWriter.i2l();
+					javaWriter.invokeStatic(LONG_COMPARE_UNSIGNED);
+					compareGeneric(expression.comparison);
+					break;
 				case FLOAT_COMPARE:
 					expression.left.accept(this);
 					expression.right.accept(this);
 			case USIZE_XOR_USIZE:
 				javaWriter.iXor();
 				break;
+			case BYTE_SHL:
+			case SBYTE_SHL:
+			case SHORT_SHL:
+			case USHORT_SHL:
 			case INT_SHL:
 			case UINT_SHL:
 			case USIZE_SHL:
 				javaWriter.iShl();
 				break;
+			case SBYTE_SHR:
+			case SHORT_SHR:
 			case INT_SHR:
 				javaWriter.iShr();
 				break;
+			case BYTE_SHR:
+			case SBYTE_USHR:
+			case USHORT_SHR:
+			case SHORT_USHR:
 			case INT_USHR:
 			case UINT_SHR:
 			case USIZE_SHR:

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

 	T copy(Expression value);
 	
 	T copyTo(CallExpression call);
+	
+	T stringToAscii(Expression value);
+	
+	T stringToUTF8(Expression value);
+	
+	T bytesAsciiToString(Expression value);
+	
+	T bytesUTF8ToString(Expression value);
 }

JavaShared/src/main/java/org/openzen/zenscript/javashared/prepare/JavaPrepareDefinitionVisitor.java

 import org.openzen.zenscript.codemodel.definition.StructDefinition;
 import org.openzen.zenscript.codemodel.definition.VariantDefinition;
 import org.openzen.zenscript.codemodel.expression.CallExpression;
+import org.openzen.zenscript.codemodel.expression.CallStaticExpression;
 import org.openzen.zenscript.codemodel.expression.CastExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.member.IDefinitionMember;
 			cls.addInstanceMethod("lastIndexOf", "lastIndexOf", "(I)I");
 			cls.addInstanceMethod("lastIndexOfFrom", "lastIndexOf", "(II)I");
 			cls.addInstanceMethod("trim", "trim", "()Ljava/lang/String;");
+			cls.addMethod("fromAsciiBytes", new JavaMethod((expression, translator) -> {
+				CallStaticExpression call = (CallStaticExpression)expression;
+				return translator.bytesAsciiToString(call.arguments.arguments[0]);
+			}));
+			cls.addMethod("fromUTF8Bytes", new JavaMethod((expression, translator) -> {
+				CallStaticExpression call = (CallStaticExpression)expression;
+				return translator.bytesUTF8ToString(call.arguments.arguments[0]);
+			}));
+			cls.addMethod("toAsciiBytes", new JavaMethod((expression, translator) -> {
+				CallExpression call = (CallExpression)expression;
+				return translator.stringToAscii(call.target);
+			}));
+			cls.addMethod("toUTF8Bytes", new JavaMethod((expression, translator) -> {
+				CallExpression call = (CallExpression)expression;
+				return translator.stringToUTF8(call.target);
+			}));
 			nativeClasses.put("stdlib::String", cls);
 		}
 		
 		{
-			JavaClass arrays = new JavaClass("java.lang", "Arrays", JavaClass.Kind.CLASS);
+			JavaClass arrays = JavaClass.ARRAYS;
 			JavaNativeClass cls = new JavaNativeClass(arrays);
 			cls.addMethod("sort", JavaMethod.getNativeExpansion(arrays, "sort", "([Ljava/lang/Object;)[Ljava/lang/Object;"));
 			cls.addMethod("sorted", new JavaMethod((expression, translator) -> {

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

 	private static final JavaClass RESULT = new JavaClass("stdlib", "Result", JavaClass.Kind.CLASS);
 	private static final JavaClass RESULT_OK = new JavaClass("stdlib", "Result.Ok", JavaClass.Kind.CLASS);
 	private static final JavaClass RESULT_ERROR = new JavaClass("stdlib", "Result.Error", JavaClass.Kind.CLASS);
+	private static final JavaClass STANDARD_CHARSETS = new JavaClass("java.nio.charset", "StandardCharsets", JavaClass.Kind.CLASS);
 	
 	public final JavaSourceStatementScope scope;
 	public final StatementFormattingTarget target;
 		if (method == null)
 			throw new IllegalStateException("No source method tag for " + expression.member.getCanonicalName() + "!");
 		
+		if (method.kind == JavaMethod.Kind.COMPILED)
+			return (ExpressionString) method.translation.translate(expression, this);
+		
 		StringBuilder result = new StringBuilder();
 		result.append(scope.type(method.cls));
 		result.append('.');
 
 	@Override
 	public ExpressionString visitConstantLong(ConstantLongExpression expression) {
-		return new ExpressionString(Long.toString(expression.value), JavaOperator.PRIMARY);
+		return new ExpressionString(Long.toString(expression.value) + "L", JavaOperator.PRIMARY);
 	}
 
 	@Override
 
 	@Override
 	public ExpressionString visitConstantULong(ConstantULongExpression expression) {
-		return new ExpressionString(Long.toString(expression.value), JavaOperator.CAST);
+		return new ExpressionString(Long.toString(expression.value) + "L", JavaOperator.CAST);
 	}
 
 	@Override
 			GenericTypeID generic = (GenericTypeID)elementType;
 			String array = scope.type(new JavaClass("java.lang.reflect", "Array", JavaClass.Kind.CLASS));
 			return new ExpressionString("(" + generic.parameter.name + "[])(" + array + ".newInstance(typeOf" + generic.parameter.name + ", " + length.value + "))", JavaOperator.CAST);
+		} else if (elementType == BasicTypeID.BYTE) {
+			return new ExpressionString("new byte[" + length.value + "]", JavaOperator.NEW);
+		} else if (elementType == BasicTypeID.USHORT) {
+			return new ExpressionString("new short[" + length.value + "]", JavaOperator.NEW);
+		} else if (elementType == BasicTypeID.UINT) {
+			return new ExpressionString("new int[" + length.value + "]", JavaOperator.NEW);
+		} else if (elementType == BasicTypeID.ULONG) {
+			return new ExpressionString("new long[" + length.value + "]", JavaOperator.NEW);
 		} else {
 			return new ExpressionString("new " + scope.type(elementType) + "[" + length.value + "]", JavaOperator.NEW);
 		}
 		return new ExpressionString(output.toString(), JavaOperator.CALL);
 	}
 	
+	public ExpressionString callAsStaticTruncated(String target, CallExpression expression, JavaOperator truncator) {
+		StringBuilder output = new StringBuilder();
+		output.append(target).append("(");
+		output.append(expression.target.accept(this).value);
+		for (Expression argument : expression.arguments.arguments) {
+			output.append(", ");
+			output.append(argument.accept(this).unaryPostfix(truncator).value);
+		}
+		output.append(")");
+		return new ExpressionString(output.toString(), JavaOperator.CALL);
+	}
+	
 	public ExpressionString callAsStatic(String target, Expression left, Expression right) {
 		StringBuilder output = new StringBuilder();
 		output.append(target).append("(");
 	}
 	
 	private ExpressionString cast(CastExpression cast, String type) {
-		StringBuilder output = new StringBuilder();
-		output.append('(');
-		output.append(type);
-		output.append(')');
-		output.append(cast.target.accept(this).value);
-		return new ExpressionString(output.toString(), JavaOperator.CAST);
+		return cast.target.accept(this).unaryPrefix(JavaOperator.CAST, "(" + type + ")");
 	}
 	
 	private ExpressionString cast(ExpressionString value, String type) {
-		StringBuilder output = new StringBuilder();
-		output.append('(');
-		output.append(type);
-		output.append(')');
-		output.append(value.value);
-		return new ExpressionString(output.toString(), JavaOperator.CAST);
+		return value.unaryPrefix(JavaOperator.CALL, "(" + type + ")");
 	}
 	
 	private ExpressionString castPostfix(CastExpression cast, JavaOperator operator) {
 			case BYTE_ADD_BYTE: return binary(call, JavaOperator.ADD);
 			case BYTE_SUB_BYTE: return binary(call, JavaOperator.SUB);
 			case BYTE_MUL_BYTE: return binary(call, JavaOperator.MUL);
-			case BYTE_DIV_BYTE: return callAsStatic("Integer.divideUnsigned", call);
-			case BYTE_MOD_BYTE: return callAsStatic("Integer.remainderUnsigned", call);
+			case BYTE_DIV_BYTE: return callAsStaticTruncated("Integer.divideUnsigned", call, JavaOperator.AND_FF);
+			case BYTE_MOD_BYTE: return callAsStaticTruncated("Integer.remainderUnsigned", call, JavaOperator.AND_FF);
 			case BYTE_AND_BYTE: return binary(call, JavaOperator.AND);
 			case BYTE_OR_BYTE: return binary(call, JavaOperator.OR);
 			case BYTE_XOR_BYTE: return binary(call, JavaOperator.XOR);
+			case BYTE_SHL: return binary(call, JavaOperator.SHL);
+			case BYTE_SHR: return binary(call, JavaOperator.SHR);
 			case SBYTE_NOT: return unaryPrefix(call, JavaOperator.INVERT);
 			case SBYTE_NEG: return unaryPrefix(call, JavaOperator.NEG);
 			case SBYTE_ADD_SBYTE: return binary(call, JavaOperator.ADD);
 			case SBYTE_AND_SBYTE: return binary(call, JavaOperator.AND);
 			case SBYTE_OR_SBYTE: return binary(call, JavaOperator.OR);
 			case SBYTE_XOR_SBYTE: return binary(call, JavaOperator.XOR);
+			case SBYTE_SHL: return binary(call, JavaOperator.SHL);
+			case SBYTE_SHR: return binary(call, JavaOperator.SHR);
+			case SBYTE_USHR: return binary(call, JavaOperator.USHR);
 			case SHORT_NOT: return unaryPrefix(call, JavaOperator.INVERT);
 			case SHORT_NEG: return unaryPrefix(call, JavaOperator.NEG);
 			case SHORT_ADD_SHORT: return binary(call, JavaOperator.ADD);
 			case SHORT_AND_SHORT: return binary(call, JavaOperator.AND);
 			case SHORT_OR_SHORT: return binary(call, JavaOperator.OR);
 			case SHORT_XOR_SHORT: return binary(call, JavaOperator.XOR);
+			case SHORT_SHL: return binary(call, JavaOperator.SHL);
+			case SHORT_SHR: return binary(call, JavaOperator.SHR);
 			case USHORT_NOT: return unaryPrefix(call, JavaOperator.INVERT);
 			case USHORT_ADD_USHORT: return binary(call, JavaOperator.ADD);
 			case USHORT_SUB_USHORT: return binary(call, JavaOperator.SUB);
 			case USHORT_MUL_USHORT: return binary(call, JavaOperator.MUL);
-			case USHORT_DIV_USHORT: return binary(call, JavaOperator.DIV);
-			case USHORT_MOD_USHORT: return binary(call, JavaOperator.MOD);
+			case USHORT_DIV_USHORT: return callAsStaticTruncated("Integer.divideUnsigned", call, JavaOperator.AND_FFFF);
+			case USHORT_MOD_USHORT: return callAsStaticTruncated("Integer.remainderUnsigned", call, JavaOperator.AND_FFFF);
 			case USHORT_AND_USHORT: return binary(call, JavaOperator.AND);
 			case USHORT_OR_USHORT: return binary(call, JavaOperator.OR);
 			case USHORT_XOR_USHORT: return binary(call, JavaOperator.XOR);
+			case USHORT_SHL: return binary(call, JavaOperator.SHL);
+			case USHORT_SHR: return binary(call, JavaOperator.SHR);
 			case INT_NOT: return unaryPrefix(call, JavaOperator.INVERT);
 			case INT_NEG: return unaryPrefix(call, JavaOperator.NEG);
 			case INT_ADD_INT: return binary(call, JavaOperator.ADD);
 			case GENERICMAP_SAME: return binary(call, JavaOperator.EQUALS);
 			case GENERICMAP_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
 			case ARRAY_INDEXGET: return new ExpressionString(call.target.accept(this) + "[" + call.arguments.arguments[0].accept(this) + "]", JavaOperator.INDEX);
-			case ARRAY_INDEXSET: return new ExpressionString(
+			case ARRAY_INDEXSET: {
+				ExpressionString value = call.arguments.arguments[1].accept(this);
+				ITypeID baseType = ((ArrayTypeID)(call.target.type)).elementType;
+				String asType = "";
+				if (baseType == BasicTypeID.BYTE) {
+					asType = "(byte)";
+				} else if (baseType == BasicTypeID.USHORT) {
+					asType = "(short)";
+				}
+				
+				if (!asType.isEmpty()) {
+					if (value.priority == JavaOperator.CAST && value.value.startsWith("(int)"))
+						value = new ExpressionString(asType + value.value.substring(5), value.priority);
+					else
+						value = value.unaryPrefix(JavaOperator.CAST, asType);
+				}
+				
+				return new ExpressionString(
 					call.target.accept(this)
 							+ "[" + call.arguments.arguments[0].accept(this)
 							+ "] = "
-							+ call.arguments.arguments[1].accept(this), JavaOperator.INDEX);
+							+ value.value, JavaOperator.INDEX);
+			}
 			case ARRAY_INDEXGETRANGE: {
 				ExpressionString left = call.target.accept(this);
 				Expression argument = call.arguments.arguments[0];
 					RangeExpression rangeArgument = (RangeExpression)argument;
 					ExpressionString from = rangeArgument.from.accept(this);
 					ExpressionString to = rangeArgument.to.accept(this);
-					return new ExpressionString("Arrays.copyOfRange(" + left.value + ", " + from.value + ", " + to.value + ")", JavaOperator.CALL);
+					return new ExpressionString(scope.type(JavaClass.ARRAYS) + ".copyOfRange(" + left.value + ", " + from.value + ", " + to.value + ")", JavaOperator.CALL);
 				} else {
 					throw new UnsupportedOperationException("Not yet supported!");
 				}
 				JavaMethod method = scope.fileScope.helperGenerator.createArrayContains((ArrayTypeID)call.target.type);
 				return callAsStatic(scope.fileScope.importer.importType(method.cls) + '.' + method.name, call);
 			}
-			case ARRAY_EQUALS: return callAsStatic("Arrays.equals", call);
-			case ARRAY_NOTEQUALS: return callAsStatic("!Arrays.equals", call);
+			case ARRAY_EQUALS: return callAsStatic(scope.type(JavaClass.ARRAYS) + ".equals", call);
+			case ARRAY_NOTEQUALS: return callAsStatic("!" + scope.type(JavaClass.ARRAYS) + ".equals", call);
 			case ARRAY_SAME: return binary(call, JavaOperator.EQUALS);
 			case ARRAY_NOTSAME: return binary(call, JavaOperator.NOTEQUALS);
 			case FUNCTION_CALL: {
 			case INT_COMPARE:
 			case USIZE_COMPARE:
 				return compare(call.left, call.right, call.comparison);
-			case UINT_COMPARE: return compare(callAsStatic("Integer.compareUnsigned", call.left, call.right), call.comparison);
-			case LONG_COMPARE: return compare(call.left, call.right, call.comparison);
-			case ULONG_COMPARE: return compare(callAsStatic("Long.compareUnsigned", call.left, call.right), call.comparison);
+			case UINT_COMPARE:
+			case USIZE_COMPARE_UINT:
+				return compare(callAsStatic("Integer.compareUnsigned", call.left, call.right), call.comparison);
+			case LONG_COMPARE:
+			case LONG_COMPARE_INT:
+				return compare(call.left, call.right, call.comparison);
+			case ULONG_COMPARE:
+			case ULONG_COMPARE_UINT:
+				return compare(callAsStatic("Long.compareUnsigned", call.left, call.right), call.comparison);
 			case FLOAT_COMPARE: return compare(call.left, call.right, call.comparison);
 			case DOUBLE_COMPARE: return compare(call.left, call.right, call.comparison);
 			case CHAR_COMPARE: return compare(call.left, call.right, call.comparison);
 			case ARRAY_LENGTH:
 				return call.target.accept(this).unaryPostfix(JavaOperator.MEMBER, ".length");
 			case ARRAY_HASHCODE:
-				return callAsStatic("Arrays.deepHashCode", call);
+				return callAsStatic(scope.type(JavaClass.ARRAYS) + ".deepHashCode", call);
 			case ARRAY_ISEMPTY:
 				return call.target.accept(this).unaryPostfix(JavaOperator.EQUALS, ".length == 0");
 			case ENUM_NAME:
 			case ULONG_TO_DOUBLE: return castImplicit(cast, "double"); // TODO: this is incorrect!
 			case ULONG_TO_CHAR: return cast(cast, "char");
 			case ULONG_TO_STRING: return callStatic("Long.toUnsignedString", cast.target);
+			case USIZE_TO_BYTE: return cast.target.accept(this);
+			case USIZE_TO_SBYTE: return cast(cast, "byte");
+			case USIZE_TO_SHORT: return cast(cast, "short");
+			case USIZE_TO_USHORT: return cast.target.accept(this);
+			case USIZE_TO_INT: return cast.target.accept(this);
+			case USIZE_TO_UINT: return cast.target.accept(this);
+			case USIZE_TO_LONG: return castImplicit(cast, "long");
+			case USIZE_TO_ULONG: return castImplicit(cast, "long");
+			case USIZE_TO_FLOAT: return castImplicit(cast, "float");
+			case USIZE_TO_DOUBLE: return castImplicit(cast, "double");
 			case FLOAT_TO_BYTE: return cast(cast, "int");
 			case FLOAT_TO_SBYTE: return cast(cast, "byte");
 			case FLOAT_TO_SHORT: return cast(cast, "short");
 			case CHAR_TO_USIZE: return castImplicit(cast, "int");
 			case CHAR_TO_STRING: return callStatic("Character.toString", cast.target);
 			case ENUM_TO_STRING: return cast.target.accept(this).unaryPostfix(JavaOperator.TOSTRING);
+			case BYTE_ARRAY_AS_SBYTE_ARRAY:
+			case SBYTE_ARRAY_AS_BYTE_ARRAY:
+			case SHORT_ARRAY_AS_USHORT_ARRAY:
+			case USHORT_ARRAY_AS_SHORT_ARRAY:
+			case INT_ARRAY_AS_UINT_ARRAY:
+			case UINT_ARRAY_AS_INT_ARRAY:
+			case LONG_ARRAY_AS_ULONG_ARRAY:
+			case ULONG_ARRAY_AS_LONG_ARRAY:
+				return cast.target.accept(this);
 		}
 		
 		throw new UnsupportedOperationException("Unknown builtin cast: " + cast.member.member.builtin);
 	public ExpressionString sorted(Expression value) {
 		Expression target = duplicable(value);
 		ExpressionString targetString = target.accept(this);
-		ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
+		ExpressionString copy = new ExpressionString(scope.type(JavaClass.ARRAYS) + ".copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
 		ExpressionString source = hoist(copy, scope.type(target.type));
-		this.target.writeLine("Arrays.sort(" + source.value + ");");
+		this.target.writeLine(scope.type(JavaClass.ARRAYS) + ".sort(" + source.value + ");");
 		return source;
 	}
 
 		Expression target = duplicable(value);
 		ExpressionString comparatorString = comparator.accept(this);
 		ExpressionString targetString = target.accept(this);
-		ExpressionString copy = new ExpressionString("Arrays.copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
+		ExpressionString copy = new ExpressionString(scope.type(JavaClass.ARRAYS) + ".copyOf(" + targetString.value + ", " + targetString.value + ".length).sort()", JavaOperator.CALL);
 		ExpressionString source = hoist(copy, scope.type(target.type));
-		this.target.writeLine("Arrays.sort(" + source.value + ", " + comparatorString.value + ");");
+		this.target.writeLine(scope.type(JavaClass.ARRAYS) + ".sort(" + source.value + ", " + comparatorString.value + ");");
 		return source;
 	}
 
 	public ExpressionString copy(Expression value) {
 		Expression target = duplicable(value);
 		ExpressionString source = target.accept(this);
-		return new ExpressionString("Arrays.copyOf(" + source.value + ", " + source.value + ".length)", JavaOperator.CALL);
+		return new ExpressionString(scope.type(JavaClass.ARRAYS) + ".copyOf(" + source.value + ", " + source.value + ".length)", JavaOperator.CALL);
 	}
 
 	@Override
 			+ targetOffset.accept(this) + ", "
 			+ length.accept(this) + ")", JavaOperator.CALL);
 	}
+
+	@Override
+	public ExpressionString stringToAscii(Expression value) {
+		String standardCharsets = scope.type(STANDARD_CHARSETS);
+		return value.accept(this).unaryPostfix(JavaOperator.CALL, ".getBytes(" + standardCharsets + ".US_ASCII)");
+	}
+
+	@Override
+	public ExpressionString stringToUTF8(Expression value) {
+		String standardCharsets = scope.type(STANDARD_CHARSETS);
+		return value.accept(this).unaryPostfix(JavaOperator.CALL, ".getBytes(" + standardCharsets + ".UTF_8)");
+	}
+
+	@Override
+	public ExpressionString bytesAsciiToString(Expression value) {
+		String standardCharsets = scope.type(STANDARD_CHARSETS);
+		return new ExpressionString(
+				"new String(" + value.accept(this).value + ", " + standardCharsets + ".US_ASCII)",
+				JavaOperator.NEW);
+	}
+
+	@Override
+	public ExpressionString bytesUTF8ToString(Expression value) {
+		String standardCharsets = scope.type(STANDARD_CHARSETS);
+		return new ExpressionString(
+				"new String(" + value.accept(this).value + ", " + standardCharsets + ".UTF_8)",
+				JavaOperator.NEW);
+	}
 }

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

 	}
 	
 	public String importType(JavaClass cls) {
-		if (imports.containsKey(cls.outer.getName())) {
+		if (cls == null)
+			throw new NullPointerException();
+		
+		if (cls.outer != null && imports.containsKey(cls.outer.getName())) {
 			JavaClass imported = imports.get(cls.outer.getName());
 			usedImports.add(imported);
 			return imported.fullName.equals(cls.outer.fullName) ? cls.getName() : cls.fullName;

Parser/src/main/java/org/openzen/zenscript/lexer/ZSTokenType.java

 	T_WHITESPACE_CARRIAGE_RETURN(true, "\r", "\r"),
 	T_IDENTIFIER("@?[a-zA-Z_][a-zA-Z_0-9]*"),
 	T_LOCAL_IDENTIFIER("$[a-zA-Z_][a-zA-Z_0-9]*"),
-	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?"),
-	T_INT("\\-?(0|[1-9][0-9]*)"),
+	T_FLOAT("\\-?(0|[1-9][0-9]*)\\.[0-9]+([eE][\\+\\-]?[0-9]+)?[a-zA-Z_]"),
+	T_INT("\\-?(0|[1-9][0-9_]*)[a-zA-Z_]*"),
+	T_PREFIXED_INT("\\-?(0b|0x|0o|0B|0X|0O)(0|[1-9a-fA-F][0-9a-fA-F_]*)(u|U|l|L|ul|UL)?"),
 	T_STRING_SQ("\"([^\"\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\""),
 	T_STRING_DQ("\'([^\'\\\\\\n]|\\\\([\'\"\\\\/bfnrt&]|u[0-9a-fA-F]{4}))*\'"),
 	T_AOPEN("\\{", "{"),

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpression.java

 	private static ParsedExpression readPrimaryExpression(CodePosition position, ZSTokenParser parser, ParsingOptions options) {
 		switch (parser.peek().getType()) {
 			case T_INT:
-				return new ParsedExpressionInt(position, Long.parseLong(parser.next().content));
+				return new ParsedExpressionInt(position, parser.next().content);
+			case T_PREFIXED_INT:
+				return ParsedExpressionInt.parsePrefixed(position, parser.next().content);
 			case T_FLOAT:
 				return new ParsedExpressionFloat(
 						position,
-						Double.parseDouble(parser.next().content));
+						parser.next().content);
 			case T_STRING_SQ:
 			case T_STRING_DQ:
 				return new ParsedExpressionString(
 						position,
 						StringExpansion.unescape(parser.next().content).orElse(error -> {
-							
 							return "INVALID_STRING";
 						}));
 			case T_IDENTIFIER: {

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionFloat.java

  */
 package org.openzen.zenscript.parser.expression;
 
+import java.util.Collections;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.ConstantDoubleExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantFloatExpression;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.partial.IPartialExpression;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.parser.PrecompilationState;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
  */
 public class ParsedExpressionFloat extends ParsedExpression {
 	public final double value;
+	public final String suffix;
 	
-	public ParsedExpressionFloat(CodePosition position, double value) {
+	public ParsedExpressionFloat(CodePosition position, String value) {
+		super(position);
+		
+		int split = value.length();
+		while (isLetter(value.charAt(split - 1)))
+			split--;
+		
+		this.value = Long.parseLong(value.substring(0, split));
+		suffix = value.substring(split);
+	}
+	
+	private ParsedExpressionFloat(CodePosition position, double value) {
 		super(position);
 		
 		this.value = value;
+		this.suffix = "";
 	}
 
 	@Override
 		if (scope.hints.isEmpty())
 			return new ConstantDoubleExpression(position, value);
 		
+		if (suffix.equals("f") || suffix.equals("F"))
+			return new ConstantFloatExpression(position, (float)value);
+		if (suffix.equals("d") || suffix.equals("D"))
+			return new ConstantDoubleExpression(position, value);
+		
 		for (ITypeID hint : scope.hints) {
-			if (hint == BasicTypeID.DOUBLE)
-				return new ConstantDoubleExpression(position, value);
-			else if (hint == BasicTypeID.FLOAT)
-				return new ConstantFloatExpression(position, (float) value);
+			if (suffix.isEmpty()) {
+				if (hint == BasicTypeID.DOUBLE)
+					return new ConstantDoubleExpression(position, value);
+				else if (hint == BasicTypeID.FLOAT)
+					return new ConstantFloatExpression(position, (float) value);
+			} else {
+				TypeMembers members = scope.getTypeMembers(hint);
+				FunctionalMemberRef method = members.getOrCreateGroup(suffix, true).getStaticMethod(1, hint);
+				if (method != null) {
+					ParsedCallArguments parsedArguments = new ParsedCallArguments(Collections.emptyList(), Collections.singletonList(new ParsedExpressionFloat(position, value)));
+					CallArguments arguments = parsedArguments.compileCall(position, scope, ITypeID.NONE, method.getHeader());
+					method.callStatic(position, hint, method.getHeader(), arguments, scope);
+				}
+			}
 		}
 		
-		StringBuilder types = new StringBuilder();
-		for (int i = 0; i < scope.hints.size(); i++) {
-			if (i > 0)
-				types.append(", ");
-			
-			types.append(scope.hints.get(i).toString());
+		if (suffix.isEmpty()) {
+			StringBuilder types = new StringBuilder();
+			for (int i = 0; i < scope.hints.size(); i++) {
+				if (i > 0)
+					types.append(", ");
+
+				types.append(scope.hints.get(i).toString());
+			}
+
+			throw new CompileException(position, CompileExceptionCode.INVALID_CAST, "Cannot cast a floating-point value to any of these types: " + types);
+		} else {
+			throw new CompileException(position, CompileExceptionCode.INVALID_SUFFIX, "Invalid suffix: " + suffix);
 		}
-		
-		throw new CompileException(position, CompileExceptionCode.INVALID_CAST, "Cannot cast a floating-point value to any of these types: " + types);
 	}
 
 	@Override
 	public boolean hasStrongType() {
 		return false;
 	}
+	
+	private static boolean isLetter(char c) {
+		return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
+	}
 }

Parser/src/main/java/org/openzen/zenscript/parser/expression/ParsedExpressionInt.java

  */
 package org.openzen.zenscript.parser.expression;
 
+import java.util.Collections;
 import org.openzen.zencode.shared.CodePosition;
 import org.openzen.zencode.shared.CompileException;
 import org.openzen.zencode.shared.CompileExceptionCode;
+import org.openzen.zenscript.codemodel.expression.CallArguments;
 import org.openzen.zenscript.codemodel.expression.ConstantByteExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantCharExpression;
 import org.openzen.zenscript.codemodel.expression.ConstantIntExpression;
 import org.openzen.zenscript.codemodel.expression.Expression;
 import org.openzen.zenscript.codemodel.expression.switchvalue.IntSwitchValue;
 import org.openzen.zenscript.codemodel.expression.switchvalue.SwitchValue;
+import org.openzen.zenscript.codemodel.member.ref.FunctionalMemberRef;
 import org.openzen.zenscript.codemodel.type.BasicTypeID;
 import org.openzen.zenscript.codemodel.type.ITypeID;
 import org.openzen.zenscript.codemodel.scope.ExpressionScope;
-import org.openzen.zenscript.parser.PrecompilationState;
+import org.openzen.zenscript.codemodel.type.member.TypeMembers;
 
 /**
  *
  * @author Hoofdgebruiker
  */
 public class ParsedExpressionInt extends ParsedExpression {
+	public static ParsedExpressionInt parsePrefixed(CodePosition position, String value) {
+		boolean negative = value.startsWith("-");
+		if (negative)
+			value = value.substring(1);
+		
+		String suffix = "";
+		if (value.endsWith("u") || value.endsWith("l") || value.endsWith("U") || value.endsWith("L")) {
+			suffix = value.substring(value.length() - 1);
+			value = value.substring(0, value.length() - 1);
+		} else if (value.endsWith("ul") || value.endsWith("UL")) {
+			suffix = value.substring(value.length() - 2);
+			value = value.substring(0, value.length() - 2);
+		}
+		
+		value = value.toLowerCase();
+		
+		long parsed = 0;
+		if (value.startsWith("0x")) {
+			for (char c : value.substring(2).toCharArray()) {
+				if (c >= '0' && c <= '9')
+					parsed = parsed * 16 + (c - '0');
+				else if (c >= 'a' && c <= 'f')
+					parsed = parsed * 16 + 10 + (c - 'a');
+				else if (c != '_')
+					throw new NumberFormatException("Invalid number: " + value);
+			}
+		} else if (value.startsWith("0b")) {
+			for (char c : value.substring(2).toCharArray()) {
+				if (c == '0')
+					parsed = parsed * 2;
+				else if (c == '1')
+					parsed = parsed * 2 + 1;
+				else if (c != '_')
+					throw new NumberFormatException("Invalid number: " + value);
+			}
+		} else if (value.startsWith("0o")) {
+			for (char c : value.substring(2).toCharArray()) {
+				if (c >= '0' && c <= '7')
+					parsed = parsed * 8 + c - '0';
+				else if (c != '_')
+					throw new NumberFormatException("Invalid number: " + value);
+			}
+		} else {
+			throw new NumberFormatException("Invalid number: " + value);
+		}
+		
+		return new ParsedExpressionInt(position, negative, negative ? -parsed : parsed, suffix);
+	}
+	
+	public final boolean negative;
 	public final long value;
+	public final String suffix;
 	
-	public ParsedExpressionInt(CodePosition position, long value) {
+	public ParsedExpressionInt(CodePosition position, String value) {
 		super(position);
 		
+		int split = value.length();
+		while (isLetter(value.charAt(split - 1)))
+			split--;
+		
+		negative = value.charAt(0) == '-';
+		this.value = Long.parseLong(value.substring(0, split));
+		suffix = value.substring(split);
+	}
+	
+	private ParsedExpressionInt(CodePosition position, boolean negative, long value, String suffix) {
+		super(position);
+		
+		this.negative = negative;
 		this.value = value;
+		this.suffix = suffix;
 	}
-
+	
 	@Override
 	public Expression compile(ExpressionScope scope) {
+		if (suffix.equals("L") || suffix.equals("l"))
+			return new ConstantLongExpression(position, value);
+		if (suffix.equals("UL") || suffix.equals("ul"))
+			return new ConstantULongExpression(position, value);
+		if (suffix.equals("U") || suffix.equals("u"))
+			return new ConstantUIntExpression(position, (int)value);
+		
 		for (ITypeID hint : scope.hints) {
-			if (hint instanceof BasicTypeID) {
+			if (suffix.isEmpty() && (hint instanceof BasicTypeID)) {
 				switch ((BasicTypeID) hint) {
 					case SBYTE:
 						return new ConstantSByteExpression(position, (byte) value);
 					case BYTE:
-						return new ConstantByteExpression(position, (byte) value);
+						if (negative)
+							break;
+						
+						return new ConstantByteExpression(position, (int)(value & 0xFF));
 					case SHORT:
 						return new ConstantShortExpression(position, (short) value);
 					case USHORT:
-						return new ConstantUShortExpression(position, (short) value);
+						if (negative)
+							break;
+						
+						return new ConstantUShortExpression(position, (int)(value & 0xFFFF));
 					case INT:
 						return new ConstantIntExpression(position, (int) value);
 					case UINT:
+						if (negative)
+							break;
+						
 						return new ConstantUIntExpression(position, (int) value);
 					case LONG:
 						return new ConstantLongExpression(position, value);
 					case ULONG:
+						if (negative)
+							break;
+						
 						return new ConstantULongExpression(position, value);
 					case USIZE:
+						if (negative)
+							break;
+						
 						return new ConstantUSizeExpression(position, value);
 					case CHAR:
+						if (negative)
+							break;
+						
 						return new ConstantCharExpression(position, (char) value);
 					default:
 				}
+			} else if (!suffix.isEmpty()) {
+				TypeMembers members = scope.getTypeMembers(hint);
+				FunctionalMemberRef method = members.getOrCreateGroup(suffix, true).getStaticMethod(1, hint);
+				if (method != null) {
+					ParsedCallArguments parsedArguments = new ParsedCallArguments(Collections.emptyList(), Collections.singletonList(new ParsedExpressionInt(position, negative, value, "")));
+					CallArguments arguments = parsedArguments.compileCall(position, scope, ITypeID.NONE, method.getHeader());
+					method.callStatic(position, hint, method.getHeader(), arguments, scope);
+				}
 			}
 		}
 		
-		if (value <= Integer.MAX_VALUE && value >= Integer.MIN_VALUE)
-			return new ConstantIntExpression(position, (int) value);
-		else
-			return new ConstantLongExpression(position, value);
+		if (suffix.isEmpty()) {
+			if (value <= Integer.MAX_VALUE && value >= Integer.MIN_VALUE)
+				return new ConstantIntExpression(position, (int) value);
+			else
+				return new ConstantLongExpression(position, value);
+		} else {
+			throw new CompileException(position, CompileExceptionCode.INVALID_SUFFIX, "Invalid suffix: " + suffix);
+		}
 	}
 	
 	@Override
 	public boolean hasStrongType() {
 		return false;
 	}
+	
+	private static boolean isLetter(char c) {
+		return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || c == '_';
+	}
 }

ScriptingExample/build.gradle

 	compile project(':JavaBytecodeCompiler')
 	compile project(':JavaShared')
 	compile project(':CodeFormatter')
-	compile project(':ScriptingHost')
+	//compile project(':ScriptingHost')
 }

Shared/src/main/java/org/openzen/zencode/shared/CompileExceptionCode.java

 	INVALID_BRACKET_EXPRESSION,
 	VARIANT_OPTION_NOT_AN_EXPRESSION,
 	DUPLICATE_GLOBAL,
-	CANNOT_INFER_RETURN_TYPE
+	CANNOT_INFER_RETURN_TYPE,
+	INVALID_SUFFIX
 }