diff --git a/bootstrap/stage0/__unified_forward.h b/bootstrap/stage0/__unified_forward.h
index 2d4d4ec67..762cd345d 100644
--- a/bootstrap/stage0/__unified_forward.h
+++ b/bootstrap/stage0/__unified_forward.h
@@ -16,14 +16,14 @@ struct ArgsParser;
 }
 namespace jakt__platform {
 struct Target;
+JaktInternal::Optional<size_t> last_namespace_separator(DeprecatedString const name);
 
 
 
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> add_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings, DeprecatedString const prefix, DeprecatedString const suffix);
 
-JaktInternal::Optional<size_t> last_namespace_separator(DeprecatedString const name);
 
 
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> add_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings, DeprecatedString const prefix, DeprecatedString const suffix);
 
 
 
@@ -39,10 +39,10 @@ struct Path;
 }
 namespace jakt__platform__unknown_fs {
 class DirectoryIterator;
-ErrorOr<void> make_directory(DeprecatedString const path);
-
 ErrorOr<DeprecatedString> current_directory();
 
+ErrorOr<void> make_directory(DeprecatedString const path);
+
 }
 namespace jakt__file_iterator {
 class RecursiveFileIterator;
@@ -59,64 +59,64 @@ struct Continue;
 template<typename T>
 struct IterationDecision;
 
-bool is_ascii_binary(u8 const c);
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> append_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings, DeprecatedString const suffix);
 
 bool is_ascii_alpha(u8 const c);
 
 bool is_whitespace(u8 const byte);
 
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> prepend_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings, DeprecatedString const prefix);
-
 bool is_ascii_digit(u8 const c);
 
-void todo(DeprecatedString const message);
-
 bool is_ascii_alphanumeric(u8 const c);
 
-ErrorOr<DeprecatedString> interpret_escapes(DeprecatedString const s);
-
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> append_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings, DeprecatedString const suffix);
+DeprecatedString join(JaktInternal::DynamicArray<DeprecatedString> const strings, DeprecatedString const separator);
 
 ErrorOr<void> write_to_file(DeprecatedString const data, DeprecatedString const output_filename);
 
-DeprecatedString join(JaktInternal::DynamicArray<DeprecatedString> const strings, DeprecatedString const separator);
+void todo(DeprecatedString const message);
 
 bool is_ascii_octdigit(u8 const c);
 
+ErrorOr<DeprecatedString> escape_for_quotes(DeprecatedString const s);
+
 bool is_ascii_hexdigit(u8 const c);
 
+ErrorOr<DeprecatedString> interpret_escapes(DeprecatedString const s);
+
 [[noreturn]] void panic(DeprecatedString const message);
 
-ErrorOr<DeprecatedString> escape_for_quotes(DeprecatedString const s);
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> prepend_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings, DeprecatedString const prefix);
+
+bool is_ascii_binary(u8 const c);
 
 }
 namespace error {
-namespace JaktError_Details {
-struct Message;
-struct MessageWithHint;
-}
-struct JaktError;
-
 namespace MessageSeverity_Details {
 struct Hint;
 struct Error;
 }
 struct MessageSeverity;
 
+namespace JaktError_Details {
+struct Message;
+struct MessageWithHint;
+}
+struct JaktError;
+
 ErrorOr<void> print_error_json(DeprecatedString const file_name, error::JaktError const error);
 
-ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,size_t>>> gather_line_spans(JaktInternal::DynamicArray<u8> const file_contents);
+ErrorOr<void> print_error(DeprecatedString const file_name, JaktInternal::Optional<JaktInternal::DynamicArray<u8>> const file_contents, error::JaktError const error);
 
 ErrorOr<void> display_message_with_span(error::MessageSeverity const severity, DeprecatedString const file_name, JaktInternal::Optional<JaktInternal::DynamicArray<u8>> const contents, DeprecatedString const message, utility::Span const span);
 
+ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,size_t>>> gather_line_spans(JaktInternal::DynamicArray<u8> const file_contents);
+
 ErrorOr<void> print_underline(error::MessageSeverity const severity, size_t const width, JaktInternal::Tuple<size_t,size_t> const file_span, utility::Span const error_span, size_t const line_number, size_t const largest_line_number);
 
 ErrorOr<void> print_source_line(error::MessageSeverity const severity, JaktInternal::DynamicArray<u8> const file_contents, JaktInternal::Tuple<size_t,size_t> const file_span, utility::Span const error_span, size_t const line_number, size_t const largest_line_number);
 
 ErrorOr<void> display_message_with_span_json(error::MessageSeverity const severity, DeprecatedString const file_name, DeprecatedString const message, utility::Span const span);
 
-ErrorOr<void> print_error(DeprecatedString const file_name, JaktInternal::Optional<JaktInternal::DynamicArray<u8>> const file_contents, error::JaktError const error);
-
 }
 namespace compiler {
 class Compiler;
@@ -265,39 +265,111 @@ struct LiteralPrefix;
 
 }
 namespace parser {
-struct ParsedGenericParameter;
-struct ParsedField;
-struct EnumVariantPatternArgument;
-struct ParsedPatternDefault;
-struct ParsedRecord;
-struct ParsedExternalTraitImplementation;
+struct ParsedMatchCase;
 struct ParsedFunction;
-struct ParsedExternImport;
 struct ParsedModuleImport;
 struct ParsedVariable;
 struct ParsedNameWithGenericParameters;
-struct SumEnumVariant;
-struct ParsedBlock;
-struct ParsedAttributeArgument;
 struct ParsedVarDeclTuple;
-struct ParsedAttribute;
+struct ParsedAttributeArgument;
+struct ParsedVarDecl;
+struct ParsedNamespace;
+struct ParsedMethod;
+struct ParsedExternalTraitImplementation;
+struct ParsedGenericParameter;
 struct ParsedTrait;
-struct Parser;
+struct ParsedExternImport;
 struct ParsedCall;
-struct ParsedNamespace;
+struct SumEnumVariant;
+struct VisibilityRestriction;
 struct ParsedName;
+struct ParsedField;
 struct ParsedAlias;
-struct ParsedVarDecl;
-struct ParsedMethod;
-struct ParsedMatchCase;
+struct Parser;
+struct EnumVariantPatternArgument;
+struct ParsedPatternDefault;
 struct ParsedParameter;
 struct ValueEnumVariant;
-struct VisibilityRestriction;
-namespace IncludeAction_Details {
-struct Define;
-struct Undefine;
+struct ParsedRecord;
+struct ParsedAttribute;
+struct ParsedBlock;
+namespace ImportName_Details {
+struct Literal;
+struct Comptime;
 }
-struct IncludeAction;
+struct ImportName;
+
+namespace ParsedMatchPattern_Details {
+struct EnumVariant;
+struct Expression;
+struct CatchAll;
+struct Invalid;
+}
+struct ParsedMatchPattern;
+
+namespace Visibility_Details {
+struct Public;
+struct Private;
+struct Restricted;
+}
+struct Visibility;
+
+namespace ArgumentStoreLevel_Details {
+struct InObject;
+struct InStaticStorage;
+}
+struct ArgumentStoreLevel;
+
+namespace ParsedMatchBody_Details {
+struct Expression;
+struct Block;
+}
+struct ParsedMatchBody;
+
+namespace ParsedCapture_Details {
+struct ByValue;
+struct ByReference;
+struct ByMutableReference;
+struct ByComptimeDependency;
+struct AllByReference;
+}
+struct ParsedCapture;
+
+namespace ParsedType_Details {
+struct Name;
+struct NamespacedName;
+struct GenericType;
+struct JaktArray;
+struct Dictionary;
+struct JaktTuple;
+struct Set;
+struct Optional;
+struct Reference;
+struct MutableReference;
+struct RawPtr;
+struct WeakPtr;
+struct Function;
+struct Empty;
+}
+struct ParsedType;
+
+namespace TypeCast_Details {
+struct Fallible;
+struct Infallible;
+}
+struct TypeCast;
+
+namespace DefinitionLinkage_Details {
+struct Internal;
+struct External;
+}
+struct DefinitionLinkage;
+
+namespace ImportList_Details {
+struct List;
+struct All;
+}
+struct ImportList;
 
 namespace ParsedExpression_Details {
 struct Boolean;
@@ -333,20 +405,30 @@ struct Garbage;
 }
 struct ParsedExpression;
 
-namespace ImportList_Details {
-struct List;
-struct All;
+namespace FunctionLinkage_Details {
+struct Internal;
+struct External;
 }
-struct ImportList;
+struct FunctionLinkage;
 
-namespace ParsedCapture_Details {
-struct ByValue;
-struct ByReference;
-struct ByMutableReference;
-struct ByComptimeDependency;
-struct AllByReference;
+namespace UnaryOperator_Details {
+struct PreIncrement;
+struct PostIncrement;
+struct PreDecrement;
+struct PostDecrement;
+struct Negate;
+struct Dereference;
+struct RawAddress;
+struct Reference;
+struct MutableReference;
+struct LogicalNot;
+struct BitwiseNot;
+struct TypeCast;
+struct Is;
+struct IsEnumVariant;
+struct Sizeof;
 }
-struct ParsedCapture;
+struct UnaryOperator;
 
 namespace BinaryOperator_Details {
 struct Add;
@@ -386,16 +468,22 @@ struct Garbage;
 }
 struct BinaryOperator;
 
-namespace FunctionType_Details {
-struct Normal;
-struct Destructor;
-struct ImplicitConstructor;
-struct ImplicitEnumConstructor;
-struct ExternalClassConstructor;
-struct Expression;
-struct Closure;
+namespace NumericConstant_Details {
+struct I8;
+struct I16;
+struct I32;
+struct I64;
+struct U8;
+struct U16;
+struct U32;
+struct U64;
+struct USize;
+struct F32;
+struct F64;
+struct UnknownSigned;
+struct UnknownUnsigned;
 }
-struct FunctionType;
+struct NumericConstant;
 
 namespace ParsedStatement_Details {
 struct Expression;
@@ -419,37 +507,11 @@ struct Garbage;
 }
 struct ParsedStatement;
 
-namespace ParsedMatchPattern_Details {
-struct EnumVariant;
-struct Expression;
-struct CatchAll;
-struct Invalid;
-}
-struct ParsedMatchPattern;
-
-namespace FunctionLinkage_Details {
-struct Internal;
-struct External;
-}
-struct FunctionLinkage;
-
-namespace ImportName_Details {
-struct Literal;
-struct Comptime;
-}
-struct ImportName;
-
-namespace ParsedMatchBody_Details {
-struct Expression;
-struct Block;
-}
-struct ParsedMatchBody;
-
-namespace DefinitionLinkage_Details {
-struct Internal;
-struct External;
+namespace IncludeAction_Details {
+struct Define;
+struct Undefine;
 }
-struct DefinitionLinkage;
+struct IncludeAction;
 
 namespace RecordType_Details {
 struct Struct;
@@ -460,78 +522,16 @@ struct Garbage;
 }
 struct RecordType;
 
-namespace Visibility_Details {
-struct Public;
-struct Private;
-struct Restricted;
-}
-struct Visibility;
-
-namespace ArgumentStoreLevel_Details {
-struct InObject;
-struct InStaticStorage;
-}
-struct ArgumentStoreLevel;
-
-namespace ParsedType_Details {
-struct Name;
-struct NamespacedName;
-struct GenericType;
-struct JaktArray;
-struct Dictionary;
-struct JaktTuple;
-struct Set;
-struct Optional;
-struct Reference;
-struct MutableReference;
-struct RawPtr;
-struct WeakPtr;
-struct Function;
-struct Empty;
-}
-struct ParsedType;
-
-namespace TypeCast_Details {
-struct Fallible;
-struct Infallible;
-}
-struct TypeCast;
-
-namespace NumericConstant_Details {
-struct I8;
-struct I16;
-struct I32;
-struct I64;
-struct U8;
-struct U16;
-struct U32;
-struct U64;
-struct USize;
-struct F32;
-struct F64;
-struct UnknownSigned;
-struct UnknownUnsigned;
-}
-struct NumericConstant;
-
-namespace UnaryOperator_Details {
-struct PreIncrement;
-struct PostIncrement;
-struct PreDecrement;
-struct PostDecrement;
-struct Negate;
-struct Dereference;
-struct RawAddress;
-struct Reference;
-struct MutableReference;
-struct LogicalNot;
-struct BitwiseNot;
-struct TypeCast;
-struct Is;
-struct IsEnumVariant;
-struct Sizeof;
+namespace FunctionType_Details {
+struct Normal;
+struct Destructor;
+struct ImplicitConstructor;
+struct ImplicitEnumConstructor;
+struct ExternalClassConstructor;
+struct Expression;
+struct Closure;
 }
-struct UnaryOperator;
+struct FunctionType;
 
 ErrorOr<utility::Span> merge_spans(utility::Span const start, utility::Span const end);
 
@@ -540,38 +540,57 @@ f32 f64_to_f32(f64 const number);
 }
 namespace types {
 class FunctionGenerics;
+struct StructId;
 struct CheckedStringLiteral;
 struct GenericInferences;
-struct CheckedStruct;
+class CheckedFunction;
+struct ScopeId;
+struct LoadedModule;
 class CheckedVariable;
-class CheckedProgram;
+class CheckedTrait;
 struct Value;
-struct VarId;
+class CheckedProgram;
+struct ResolvedNamespace;
 class TypecheckFunctions;
+struct CheckedStruct;
 struct CheckedParameter;
 struct CheckedCall;
 struct CheckedVarDecl;
+struct FunctionGenericParameter;
 struct CheckedNamespace;
+struct CheckedField;
 struct CheckedGenericParameter;
+class Scope;
+struct TypeId;
+struct FieldRecord;
+struct CheckedEnum;
 struct CheckedBlock;
 struct TraitId;
 struct FunctionId;
 class Module;
-class CheckedTrait;
-class CheckedFunction;
-struct EnumId;
-struct StructId;
-struct ScopeId;
-struct LoadedModule;
-struct CheckedEnum;
-struct FunctionGenericParameter;
-struct ResolvedNamespace;
-class Scope;
-struct TypeId;
-struct FieldRecord;
+struct VarId;
 struct ModuleId;
+struct EnumId;
 struct CheckedEnumVariantBinding;
-struct CheckedField;
+namespace CheckedUnaryOperator_Details {
+struct PreIncrement;
+struct PostIncrement;
+struct PreDecrement;
+struct PostDecrement;
+struct Negate;
+struct Dereference;
+struct RawAddress;
+struct Reference;
+struct MutableReference;
+struct LogicalNot;
+struct BitwiseNot;
+struct TypeCast;
+struct Is;
+struct IsEnumVariant;
+struct Sizeof;
+}
+struct CheckedUnaryOperator;
+
 namespace NumericOrStringValue_Details {
 struct StringValue;
 struct SignedNumericValue;
@@ -620,31 +639,6 @@ struct Self;
 }
 struct Type;
 
-namespace CheckedMatchBody_Details {
-struct Expression;
-struct Block;
-}
-struct CheckedMatchBody;
-
-namespace CheckedStatement_Details {
-struct Expression;
-struct Defer;
-struct DestructuringAssignment;
-struct VarDecl;
-struct If;
-struct Block;
-struct Loop;
-struct While;
-struct Return;
-struct Break;
-struct Continue;
-struct Throw;
-struct Yield;
-struct InlineCpp;
-struct Garbage;
-}
-struct CheckedStatement;
-
 namespace ValueImpl_Details {
 struct Void;
 struct Bool;
@@ -677,11 +671,41 @@ struct Function;
 }
 struct ValueImpl;
 
-namespace StructOrEnumId_Details {
-struct Struct;
-struct Enum;
+namespace BlockControlFlow_Details {
+struct AlwaysReturns;
+struct AlwaysTransfersControl;
+struct NeverReturns;
+struct MayReturn;
+struct PartialAlwaysReturns;
+struct PartialAlwaysTransfersControl;
+struct PartialNeverReturns;
 }
-struct StructOrEnumId;
+struct BlockControlFlow;
+
+namespace CheckedMatchBody_Details {
+struct Expression;
+struct Block;
+}
+struct CheckedMatchBody;
+
+namespace CheckedStatement_Details {
+struct Expression;
+struct Defer;
+struct DestructuringAssignment;
+struct VarDecl;
+struct If;
+struct Block;
+struct Loop;
+struct While;
+struct Return;
+struct Break;
+struct Continue;
+struct Throw;
+struct Yield;
+struct InlineCpp;
+struct Garbage;
+}
+struct CheckedStatement;
 
 namespace CheckedEnumVariant_Details {
 struct Untyped;
@@ -711,35 +735,27 @@ struct Floating;
 }
 struct NumberConstant;
 
-namespace CheckedUnaryOperator_Details {
-struct PreIncrement;
-struct PostIncrement;
-struct PreDecrement;
-struct PostDecrement;
-struct Negate;
-struct Dereference;
-struct RawAddress;
-struct Reference;
-struct MutableReference;
-struct LogicalNot;
-struct BitwiseNot;
-struct TypeCast;
-struct Is;
-struct IsEnumVariant;
-struct Sizeof;
+namespace CheckedVisibility_Details {
+struct Public;
+struct Private;
+struct Restricted;
 }
-struct CheckedUnaryOperator;
+struct CheckedVisibility;
 
-namespace BlockControlFlow_Details {
-struct AlwaysReturns;
-struct AlwaysTransfersControl;
-struct NeverReturns;
-struct MayReturn;
-struct PartialAlwaysReturns;
-struct PartialAlwaysTransfersControl;
-struct PartialNeverReturns;
+namespace CheckedNumericConstant_Details {
+struct I8;
+struct I16;
+struct I32;
+struct I64;
+struct U8;
+struct U16;
+struct U32;
+struct U64;
+struct USize;
+struct F32;
+struct F64;
 }
-struct BlockControlFlow;
+struct CheckedNumericConstant;
 
 namespace CheckedCapture_Details {
 struct ByValue;
@@ -750,6 +766,12 @@ struct AllByReference;
 }
 struct CheckedCapture;
 
+namespace StructOrEnumId_Details {
+struct Struct;
+struct Enum;
+}
+struct StructOrEnumId;
+
 namespace SafetyMode_Details {
 struct Safe;
 struct Unsafe;
@@ -762,6 +784,18 @@ struct Unresolved;
 }
 struct MaybeResolvedScope;
 
+namespace StringLiteral_Details {
+struct Static;
+}
+struct StringLiteral;
+
+namespace StructLikeId_Details {
+struct Struct;
+struct Enum;
+struct Trait;
+}
+struct StructLikeId;
+
 namespace CheckedExpression_Details {
 struct Boolean;
 struct NumericConstant;
@@ -801,40 +835,6 @@ struct Garbage;
 }
 struct CheckedExpression;
 
-namespace StringLiteral_Details {
-struct Static;
-}
-struct StringLiteral;
-
-namespace StructLikeId_Details {
-struct Struct;
-struct Enum;
-struct Trait;
-}
-struct StructLikeId;
-
-namespace CheckedVisibility_Details {
-struct Public;
-struct Private;
-struct Restricted;
-}
-struct CheckedVisibility;
-
-namespace CheckedNumericConstant_Details {
-struct I8;
-struct I16;
-struct I32;
-struct I64;
-struct U8;
-struct U16;
-struct U32;
-struct U64;
-struct USize;
-struct F32;
-struct F64;
-}
-struct CheckedNumericConstant;
-
 namespace BuiltinType_Details {
 struct Void;
 struct Bool;
@@ -867,32 +867,30 @@ types::TypeId never_type_id();
 
 }
 namespace interpreter {
-class Interpreter;
 class InterpreterScope;
-namespace StatementResult_Details {
+class Interpreter;
+enum class InterpretError: i32;
+namespace ExecutionResult_Details {
 struct Return;
 struct Throw;
-struct Yield;
-struct Continue;
-struct Break;
-struct JustValue;
 }
-struct StatementResult;
+struct ExecutionResult;
 
-enum class InterpretError: i32;
 namespace Deferred_Details {
 struct Expression;
 struct Statement;
 }
 struct Deferred;
 
-namespace ExecutionResult_Details {
+namespace StatementResult_Details {
 struct Return;
 struct Throw;
+struct Yield;
+struct Continue;
+struct Break;
+struct JustValue;
 }
-struct ExecutionResult;
-
-ErrorOr<DeprecatedString> comptime_format_impl(DeprecatedString const format_string, JaktInternal::ArraySlice<types::Value> const arguments, NonnullRefPtr<interpreter::Interpreter> const interpreter);
+struct StatementResult;
 
 ErrorOr<size_t> align_of_impl(types::TypeId const type_id, NonnullRefPtr<interpreter::Interpreter> const interpreter);
 
@@ -904,19 +902,15 @@ ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> value_to_checked_expre
 
 ErrorOr<DeprecatedString> format_value_impl(DeprecatedString const format_string, types::Value const value, NonnullRefPtr<interpreter::Interpreter> const interpreter);
 
+ErrorOr<DeprecatedString> comptime_format_impl(DeprecatedString const format_string, JaktInternal::ArraySlice<types::Value> const arguments, NonnullRefPtr<interpreter::Interpreter> const interpreter);
+
 }
 namespace typechecker {
 struct TraitImplementationDescriptor;
+struct TraitImplCheck;
 struct AlreadyImplementedFor;
 struct ImportRestrictions;
 struct Typechecker;
-struct TraitImplCheck;
-namespace FunctionMatchResult_Details {
-struct MatchSuccess;
-struct MatchError;
-}
-struct FunctionMatchResult;
-
 namespace NumericOrStringValue_Details {
 struct StringValue;
 struct SignedNumericValue;
@@ -924,12 +918,18 @@ struct UnsignedNumericValue;
 }
 struct NumericOrStringValue;
 
+namespace FunctionMatchResult_Details {
+struct MatchSuccess;
+struct MatchError;
+}
+struct FunctionMatchResult;
+
 }
 namespace codegen {
-struct LineSpan;
+struct ControlFlowState;
 struct CodegenDebugInfo;
+struct LineSpan;
 struct CodeGenerator;
-struct ControlFlowState;
 namespace AllowedControlExits_Details {
 struct Nothing;
 struct JustReturn;
@@ -947,14 +947,6 @@ struct FormattedToken;
 struct ReflowState;
 struct Formatter;
 struct Stage0;
-namespace BreakablePoint_Details {
-struct Paren;
-struct Curly;
-struct Square;
-struct Logical;
-}
-struct BreakablePoint;
-
 namespace State_Details {
 struct Toplevel;
 struct Import;
@@ -972,14 +964,6 @@ struct FunctionTypeContext;
 }
 struct State;
 
-namespace Entity_Details {
-struct Struct;
-struct Enum;
-struct Namespace;
-struct Function;
-}
-struct Entity;
-
 namespace ExpressionMode_Details {
 struct OutsideExpression;
 struct BeforeExpressions;
@@ -988,14 +972,30 @@ struct InExpression;
 }
 struct ExpressionMode;
 
+namespace BreakablePoint_Details {
+struct Paren;
+struct Curly;
+struct Square;
+struct Logical;
+}
+struct BreakablePoint;
+
+namespace Entity_Details {
+struct Struct;
+struct Enum;
+struct Namespace;
+struct Function;
+}
+struct Entity;
+
 void bubble_sort(JaktInternal::DynamicArray<DeprecatedString> values);
 
 }
 namespace jakt__libc__io {
 }
 namespace repl {
-struct Editor;
 struct REPL;
+struct Editor;
 namespace LineResult_Details {
 struct Line;
 struct Eof;
@@ -1019,6 +1019,14 @@ struct Mutable;
 }
 struct Mutability;
 
+namespace VarVisibility_Details {
+struct DoesNotApply;
+struct Public;
+struct Private;
+struct Restricted;
+}
+struct VarVisibility;
+
 namespace Usage_Details {
 struct Variable;
 struct Call;
@@ -1034,21 +1042,13 @@ struct Field;
 }
 struct VarType;
 
-namespace VarVisibility_Details {
-struct DoesNotApply;
-struct Public;
-struct Private;
-struct Restricted;
-}
-struct VarVisibility;
-
 ErrorOr<ide::JaktSymbol> record_to_symbol(parser::ParsedRecord const record);
 
-ErrorOr<JaktInternal::Optional<DeprecatedString>> find_typename_in_program(NonnullRefPtr<types::CheckedProgram> const program, utility::Span const span);
+ErrorOr<ide::Usage> get_enum_variant_usage_from_type_id_and_name(NonnullRefPtr<types::CheckedProgram> const program, types::TypeId const type_id, DeprecatedString const name);
 
 ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> completions_for_type_id(NonnullRefPtr<types::CheckedProgram> const program, types::TypeId const type_id);
 
-ErrorOr<ide::Usage> get_enum_variant_usage_from_type_id_and_name(NonnullRefPtr<types::CheckedProgram> const program, types::TypeId const type_id, DeprecatedString const name);
+ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>> enum_variant_fields(NonnullRefPtr<types::CheckedProgram> const program, types::CheckedEnumVariant const checked_enum_variant);
 
 ErrorOr<DeprecatedString> get_enum_variant_signature_from_type_id_and_name(NonnullRefPtr<types::CheckedProgram> const program, types::TypeId const type_id, DeprecatedString const name);
 
@@ -1056,22 +1056,18 @@ ErrorOr<DeprecatedString> get_type_signature(NonnullRefPtr<types::CheckedProgram
 
 ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_scope(NonnullRefPtr<types::CheckedProgram> const program, NonnullRefPtr<types::Scope> const scope, utility::Span const span);
 
-ErrorOr<DeprecatedString> get_constructor_signature(NonnullRefPtr<types::CheckedProgram> const program, types::FunctionId const function_id);
-
 ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> find_dot_completions(NonnullRefPtr<types::CheckedProgram> const program, utility::Span const span);
 
 ErrorOr<utility::Span> find_definition_in_program(NonnullRefPtr<types::CheckedProgram> const program, utility::Span const span);
 
 ErrorOr<DeprecatedString> get_var_signature(NonnullRefPtr<types::CheckedProgram> const program, DeprecatedString const name, types::TypeId const var_type_id, ide::Mutability const mutability, ide::VarType const var_type, ide::VarVisibility const visibility, JaktInternal::Optional<types::TypeId> const struct_type_id);
 
-ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>> enum_variant_fields(NonnullRefPtr<types::CheckedProgram> const program, types::CheckedEnumVariant const checked_enum_variant);
+ErrorOr<DeprecatedString> get_constructor_signature(NonnullRefPtr<types::CheckedProgram> const program, types::FunctionId const function_id);
 
 ErrorOr<utility::Span> find_type_definition_in_program(NonnullRefPtr<types::CheckedProgram> const program, utility::Span const span);
 
 ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_expression(NonnullRefPtr<types::CheckedProgram> const program, NonnullRefPtr<typename types::CheckedExpression> const expr, utility::Span const span);
 
-ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_block(NonnullRefPtr<types::CheckedProgram> const program, types::CheckedBlock const block, utility::Span const span);
-
 ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_program(NonnullRefPtr<types::CheckedProgram> const program, utility::Span const span);
 
 ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> find_function_completions_in_scope(NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::CheckedProgram> const program);
@@ -1080,15 +1076,19 @@ ErrorOr<JaktInternal::DynamicArray<ide::JaktSymbol>> find_symbols_in_namespace(p
 
 ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_function(NonnullRefPtr<types::CheckedProgram> const program, NonnullRefPtr<types::CheckedFunction> const checked_function, utility::Span const span);
 
+ErrorOr<JaktInternal::Optional<DeprecatedString>> find_typename_in_program(NonnullRefPtr<types::CheckedProgram> const program, utility::Span const span);
+
 ErrorOr<utility::Span> find_type_definition_for_type_id(NonnullRefPtr<types::CheckedProgram> const program, types::TypeId const type_id, utility::Span const span);
 
+ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_statement(NonnullRefPtr<types::CheckedProgram> const program, NonnullRefPtr<typename types::CheckedStatement> const statement, utility::Span const span);
+
 ErrorOr<DeprecatedString> get_enum_variant_signature(NonnullRefPtr<types::CheckedProgram> const program, DeprecatedString const name, types::TypeId const type_id, JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const variants, JaktInternal::Optional<types::NumberConstant> const number_constant);
 
 ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_enum(NonnullRefPtr<types::CheckedProgram> const program, types::CheckedEnum const checked_enum, utility::Span const span);
 
-ErrorOr<ide::JaktSymbol> function_to_symbol(parser::ParsedFunction const function, DeprecatedString const kind);
+ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_block(NonnullRefPtr<types::CheckedProgram> const program, types::CheckedBlock const block, utility::Span const span);
 
-ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_statement(NonnullRefPtr<types::CheckedProgram> const program, NonnullRefPtr<typename types::CheckedStatement> const statement, utility::Span const span);
+ErrorOr<ide::JaktSymbol> function_to_symbol(parser::ParsedFunction const function, DeprecatedString const kind);
 
 ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_struct(NonnullRefPtr<types::CheckedProgram> const program, types::CheckedStruct const checked_struct, utility::Span const span);
 
@@ -1098,16 +1098,16 @@ ErrorOr<DeprecatedString> get_function_signature(NonnullRefPtr<types::CheckedPro
 namespace jakt__platform__unknown_process {
 struct Process;
 struct ExitPollResult;
-ErrorOr<jakt__platform__unknown_process::Process> start_background_process(JaktInternal::DynamicArray<DeprecatedString> const args);
-
 ErrorOr<JaktInternal::Tuple<JaktInternal::Optional<size_t>,jakt__platform__unknown_process::ExitPollResult>> wait_for_some_set_of_processes_that_at_least_includes(JaktInternal::Dictionary<size_t,jakt__platform__unknown_process::Process> const& processes);
 
 ErrorOr<jakt__platform__unknown_process::ExitPollResult> wait_for_process(jakt__platform__unknown_process::Process const& process);
 
-ErrorOr<void> forcefully_kill_process(jakt__platform__unknown_process::Process const& process);
+ErrorOr<jakt__platform__unknown_process::Process> start_background_process(JaktInternal::DynamicArray<DeprecatedString> const args);
 
 ErrorOr<JaktInternal::Optional<jakt__platform__unknown_process::ExitPollResult>> poll_process_exit(jakt__platform__unknown_process::Process const& process);
 
+ErrorOr<void> forcefully_kill_process(jakt__platform__unknown_process::Process const& process);
+
 }
 namespace build {
 struct Builder;
@@ -1120,12 +1120,12 @@ ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> run_compiler(DeprecatedStr
 struct FormatRange;
 ErrorOr<void> format_output(jakt__path::Path const file_path, JaktInternal::DynamicArray<lexer::Token> const tokens, JaktInternal::Optional<FormatRange> const format_range, bool const format_debug, bool const format_inplace);
 
-ErrorOr<DeprecatedString> indent(size_t const level);
+DeprecatedString usage();
 
 DeprecatedString help();
 
-DeprecatedString usage();
-
 ErrorOr<JaktInternal::Optional<FormatRange>> parse_format_range(DeprecatedString const range, size_t const input_file_length);
 
+ErrorOr<DeprecatedString> indent(size_t const level);
+
 } // namespace Jakt
diff --git a/bootstrap/stage0/build.cpp b/bootstrap/stage0/build.cpp
index 012e9d9ee..819243b3c 100644
--- a/bootstrap/stage0/build.cpp
+++ b/bootstrap/stage0/build.cpp
@@ -8,9 +8,9 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("pool: {}", pool));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<void> build::Builder::link_into_archive(DeprecatedString const archiver,DeprecatedString const archive_filename) {
+ErrorOr<void> build::Builder::link_into_executable(DeprecatedString const cxx_compiler_path,DeprecatedString const output_filename,JaktInternal::DynamicArray<DeprecatedString> const extra_arguments) {
 {
-JaktInternal::DynamicArray<DeprecatedString> args = (TRY((DynamicArray<DeprecatedString>::create_with({archiver, Jakt::DeprecatedString("cr"sv), archive_filename}))));
+JaktInternal::DynamicArray<DeprecatedString> args = (TRY((DynamicArray<DeprecatedString>::create_with({cxx_compiler_path, Jakt::DeprecatedString("-o"sv), output_filename}))));
 {
 JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((*this).linked_files)).iterator());
 for (;;){
@@ -26,6 +26,21 @@ TRY((((args).push(file))));
 }
 }
 
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((extra_arguments).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+DeprecatedString arg = (_magic_value.value());
+{
+TRY((((args).push(arg))));
+}
+
+}
+}
+
 size_t const id = TRY((((((*this).pool)).run(args))));
 TRY((((((*this).pool)).wait_for_all_jobs_to_complete())));
 if (((((((((*this).pool)).status(id)).value())).exit_code) != static_cast<i32>(0))){
@@ -36,11 +51,15 @@ return Error::from_errno(static_cast<i32>(1));
 return {};
 }
 
-build::Builder::Builder(JaktInternal::DynamicArray<DeprecatedString> a_linked_files, JaktInternal::DynamicArray<DeprecatedString> a_files_to_compile, build::ParallelExecutionPool a_pool) :linked_files(move(a_linked_files)), files_to_compile(move(a_files_to_compile)), pool(move(a_pool)){}
+ErrorOr<build::Builder> build::Builder::for_building(JaktInternal::DynamicArray<DeprecatedString> const files,size_t const max_concurrent) {
+{
+return (build::Builder((TRY((DynamicArray<DeprecatedString>::create_with({})))),files,TRY((build::ParallelExecutionPool::create(max_concurrent)))));
+}
+}
 
-ErrorOr<void> build::Builder::link_into_executable(DeprecatedString const cxx_compiler_path,DeprecatedString const output_filename,JaktInternal::DynamicArray<DeprecatedString> const extra_arguments) {
+ErrorOr<void> build::Builder::link_into_archive(DeprecatedString const archiver,DeprecatedString const archive_filename) {
 {
-JaktInternal::DynamicArray<DeprecatedString> args = (TRY((DynamicArray<DeprecatedString>::create_with({cxx_compiler_path, Jakt::DeprecatedString("-o"sv), output_filename}))));
+JaktInternal::DynamicArray<DeprecatedString> args = (TRY((DynamicArray<DeprecatedString>::create_with({archiver, Jakt::DeprecatedString("cr"sv), archive_filename}))));
 {
 JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((*this).linked_files)).iterator());
 for (;;){
@@ -56,21 +75,6 @@ TRY((((args).push(file))));
 }
 }
 
-{
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((extra_arguments).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-DeprecatedString arg = (_magic_value.value());
-{
-TRY((((args).push(arg))));
-}
-
-}
-}
-
 size_t const id = TRY((((((*this).pool)).run(args))));
 TRY((((((*this).pool)).wait_for_all_jobs_to_complete())));
 if (((((((((*this).pool)).status(id)).value())).exit_code) != static_cast<i32>(0))){
@@ -81,11 +85,7 @@ return Error::from_errno(static_cast<i32>(1));
 return {};
 }
 
-ErrorOr<build::Builder> build::Builder::for_building(JaktInternal::DynamicArray<DeprecatedString> const files,size_t const max_concurrent) {
-{
-return (build::Builder((TRY((DynamicArray<DeprecatedString>::create_with({})))),files,TRY((build::ParallelExecutionPool::create(max_concurrent)))));
-}
-}
+build::Builder::Builder(JaktInternal::DynamicArray<DeprecatedString> a_linked_files, JaktInternal::DynamicArray<DeprecatedString> a_files_to_compile, build::ParallelExecutionPool a_pool) :linked_files(move(a_linked_files)), files_to_compile(move(a_files_to_compile)), pool(move(a_pool)){}
 
 ErrorOr<void> build::Builder::build_all(jakt__path::Path const binary_dir,Function<ErrorOr<JaktInternal::DynamicArray<DeprecatedString>>(DeprecatedString, DeprecatedString)> const& compiler_invocation) {
 {
diff --git a/bootstrap/stage0/build.h b/bootstrap/stage0/build.h
index ae7f635fe..d7401b69c 100644
--- a/bootstrap/stage0/build.h
+++ b/bootstrap/stage0/build.h
@@ -18,11 +18,11 @@ ErrorOr<void> wait_for_all_jobs_to_complete();
 ErrorOr<DeprecatedString> debug_description() const;
 };struct Builder {
   public:
-JaktInternal::DynamicArray<DeprecatedString> linked_files;JaktInternal::DynamicArray<DeprecatedString> files_to_compile;build::ParallelExecutionPool pool;ErrorOr<void> link_into_archive(DeprecatedString const archiver, DeprecatedString const archive_filename);
+JaktInternal::DynamicArray<DeprecatedString> linked_files;JaktInternal::DynamicArray<DeprecatedString> files_to_compile;build::ParallelExecutionPool pool;ErrorOr<void> link_into_executable(DeprecatedString const cxx_compiler_path, DeprecatedString const output_filename, JaktInternal::DynamicArray<DeprecatedString> const extra_arguments);
+static ErrorOr<build::Builder> for_building(JaktInternal::DynamicArray<DeprecatedString> const files, size_t const max_concurrent);
+ErrorOr<void> link_into_archive(DeprecatedString const archiver, DeprecatedString const archive_filename);
 Builder(JaktInternal::DynamicArray<DeprecatedString> a_linked_files, JaktInternal::DynamicArray<DeprecatedString> a_files_to_compile, build::ParallelExecutionPool a_pool);
 
-ErrorOr<void> link_into_executable(DeprecatedString const cxx_compiler_path, DeprecatedString const output_filename, JaktInternal::DynamicArray<DeprecatedString> const extra_arguments);
-static ErrorOr<build::Builder> for_building(JaktInternal::DynamicArray<DeprecatedString> const files, size_t const max_concurrent);
 ErrorOr<void> build_all(jakt__path::Path const binary_dir, Function<ErrorOr<JaktInternal::DynamicArray<DeprecatedString>>(DeprecatedString, DeprecatedString)> const& compiler_invocation);
 ErrorOr<DeprecatedString> debug_description() const;
 };}
diff --git a/bootstrap/stage0/codegen.cpp b/bootstrap/stage0/codegen.cpp
index 2c3f5d814..501098b4f 100644
--- a/bootstrap/stage0/codegen.cpp
+++ b/bootstrap/stage0/codegen.cpp
@@ -13,13 +13,61 @@ return ((!(((allowed_control_exits).index() == 0 /* Nothing */))));
 }
 }
 
-ErrorOr<DeprecatedString> codegen::LineSpan::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("LineSpan("sv));{
+ErrorOr<DeprecatedString> codegen::ControlFlowState::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ControlFlowState("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("start: {}, ", start));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("end: {}", end));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("allowed_exits: {}, ", allowed_exits));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("passes_through_match: {}, ", passes_through_match));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("passes_through_try: {}, ", passes_through_try));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("match_nest_level: {}", match_nest_level));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-codegen::LineSpan::LineSpan(size_t a_start, size_t a_end) :start(move(a_start)), end(move(a_end)){}
+codegen::ControlFlowState codegen::ControlFlowState::enter_function() const {
+{
+return (codegen::ControlFlowState( codegen::AllowedControlExits { typename codegen::AllowedControlExits::JustReturn() } ,false,false,((*this).match_nest_level)));
+}
+}
+
+codegen::ControlFlowState codegen::ControlFlowState::enter_loop() const {
+{
+return (codegen::ControlFlowState( codegen::AllowedControlExits { typename codegen::AllowedControlExits::AtLoop() } ,false,((*this).passes_through_try),static_cast<size_t>(0ULL)));
+}
+}
+
+codegen::ControlFlowState codegen::ControlFlowState::no_control_flow() {
+{
+return (codegen::ControlFlowState( codegen::AllowedControlExits { typename codegen::AllowedControlExits::Nothing() } ,false,false,static_cast<size_t>(0ULL)));
+}
+}
+
+bool codegen::ControlFlowState::is_match_nested() const {
+{
+return ((((*this).match_nest_level) != static_cast<size_t>(0ULL)));
+}
+}
+
+DeprecatedString codegen::ControlFlowState::choose_control_flow_macro() const {
+{
+if (codegen::are_loop_exits_allowed(((*this).allowed_exits))){
+if (((*this).is_match_nested())){
+return (Jakt::DeprecatedString("JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH"sv));
+}
+return (Jakt::DeprecatedString("JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP"sv));
+}
+return (Jakt::DeprecatedString("JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY"sv));
+}
+}
+
+codegen::ControlFlowState codegen::ControlFlowState::enter_match() const {
+{
+size_t level = ((*this).match_nest_level);
+if (((*this).passes_through_match)){
+(level = (JaktInternal::checked_add<size_t>(((*this).match_nest_level),static_cast<size_t>(1ULL))));
+}
+return (codegen::ControlFlowState(((((*this).allowed_exits)).allow_return()),true,((*this).passes_through_try),level));
+}
+}
+
+codegen::ControlFlowState::ControlFlowState(codegen::AllowedControlExits a_allowed_exits, bool a_passes_through_match, bool a_passes_through_try, size_t a_match_nest_level) :allowed_exits(move(a_allowed_exits)), passes_through_match(move(a_passes_through_match)), passes_through_try(move(a_passes_through_try)), match_nest_level(move(a_match_nest_level)){}
 
 ErrorOr<DeprecatedString> codegen::CodegenDebugInfo::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CodegenDebugInfo("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
@@ -90,6 +138,14 @@ utility::panic(Jakt::DeprecatedString("Reached end of file and could not find in
 
 codegen::CodegenDebugInfo::CodegenDebugInfo(NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::Dictionary<size_t,JaktInternal::DynamicArray<codegen::LineSpan>> a_line_spans, bool a_statement_span_comments) :compiler(move(a_compiler)), line_spans(move(a_line_spans)), statement_span_comments(move(a_statement_span_comments)){}
 
+ErrorOr<DeprecatedString> codegen::LineSpan::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("LineSpan("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("start: {}, ", start));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("end: {}", end));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+codegen::LineSpan::LineSpan(size_t a_start, size_t a_end) :start(move(a_start)), end(move(a_end)){}
+
 ErrorOr<DeprecatedString> codegen::CodeGenerator::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CodeGenerator("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
@@ -105,262 +161,333 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("fresh_label_counter: {}", fresh_label_counter));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function(NonnullRefPtr<types::CheckedFunction> const function,bool const as_method) {
-{
-if (((function)->is_comptime)){
-return (Jakt::DeprecatedString(""sv));
-}
-return (TRY((((*this).codegen_function_in_namespace(function,JaktInternal::OptionalNone(),as_method,false,JaktInternal::OptionalNone())))));
-}
-}
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_generic_type_instance(types::StructId const id,JaktInternal::DynamicArray<types::TypeId> const args,bool const as_namespace) const {
+ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> codegen::CodeGenerator::generate(NonnullRefPtr<compiler::Compiler> const compiler,NonnullRefPtr<types::CheckedProgram> const program,bool const debug_info) {
 {
+codegen::CodeGenerator generator = codegen::CodeGenerator(compiler,program,codegen::ControlFlowState( codegen::AllowedControlExits { typename codegen::AllowedControlExits::Nothing() } ,false,false,static_cast<size_t>(0ULL)),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({})))),Jakt::DeprecatedString(""sv),JaktInternal::OptionalNone(),false,codegen::CodegenDebugInfo(compiler,(TRY((Dictionary<size_t, JaktInternal::DynamicArray<codegen::LineSpan>>::create_with_entries({})))),debug_info),(TRY((DynamicArray<DeprecatedString>::create_with({})))),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL));
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>> result = (TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with_entries({}))));
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-NonnullRefPtr<types::Module> const type_module = ((((*this).program))->get_module(((id).module)));
-DeprecatedString namespace_ = Jakt::DeprecatedString(""sv);
-if (((type_module)->is_prelude())){
-(namespace_ += Jakt::DeprecatedString("JaktInternal::"sv));
-}
-JaktInternal::Optional<types::StructId> const inner_weak_ptr_struct_id = TRY((((((*this).program))->check_and_extract_weak_ptr(id,args))));
-if (((inner_weak_ptr_struct_id).has_value())){
-(output += Jakt::DeprecatedString("WeakPtr<"sv));
-(output += namespace_);
-types::StructId const inner_struct_id = ((inner_weak_ptr_struct_id).value());
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(inner_struct_id));
-(output += TRY((((*this).codegen_namespace_qualifier(((struct_).scope_id),true,JaktInternal::OptionalNone())))));
-(output += ((struct_).name_for_codegen()));
-(output += Jakt::DeprecatedString(">"sv));
-}
-else {
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
-bool const acquired_by_ref = ((!(as_namespace)) && ((((struct_).record_type)).index() == 1 /* Class */));
-if (acquired_by_ref){
-(output += Jakt::DeprecatedString("NonnullRefPtr<"sv));
-}
-(output += namespace_);
-(output += TRY((((*this).codegen_namespace_qualifier(((struct_).scope_id),true,JaktInternal::OptionalNone())))));
-(output += ((struct_).name_for_codegen()));
-(output += Jakt::DeprecatedString("<"sv));
-bool first = true;
+(output += Jakt::DeprecatedString("#pragma once\n"sv));
+(output += Jakt::DeprecatedString("#include <lib.h>\n"sv));
+(output += Jakt::DeprecatedString("#ifdef _WIN32\n"sv));
+(output += Jakt::DeprecatedString("extern \"C\" __cdecl int SetConsoleOutputCP(unsigned int code_page);\n"sv));
+(output += Jakt::DeprecatedString("const unsigned int CP_UTF8 = 65001;\n"sv));
+(output += Jakt::DeprecatedString("#endif\n"sv));
+JaktInternal::DynamicArray<types::ModuleId> const sorted_modules = TRY((((generator).topologically_sort_modules())));
+(output += Jakt::DeprecatedString("namespace Jakt {\n"sv));
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(((sorted_modules).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
 for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId type_id = (_magic_value.value());
+size_t idx = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(","sv));
-}
-else {
-(first = false);
-}
-
-(output += TRY((((*this).codegen_type(type_id)))));
-}
-
-}
-}
-
-(output += Jakt::DeprecatedString(">"sv));
-if (acquired_by_ref){
-(output += Jakt::DeprecatedString(">"sv));
+size_t const i = ((((sorted_modules)[(JaktInternal::checked_sub<size_t>(idx,static_cast<size_t>(1ULL)))])).id);
+if ((i == static_cast<size_t>(0ULL))){
+continue;
 }
+NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[i]);
+((((generator).compiler))->dbg_println(TRY((__jakt_format(Jakt::DeprecatedString("generate: module idx: {}, module.name {}"sv),i,((module)->name))))));
+types::ScopeId const scope_id = types::ScopeId(((module)->id),static_cast<size_t>(0ULL));
+NonnullRefPtr<types::Scope> const scope = TRY((((((generator).program))->get_scope(scope_id))));
+(output += TRY((((generator).codegen_namespace_predecl(scope,module)))));
 }
 
-return (output);
 }
 }
 
-ErrorOr<JaktInternal::DynamicArray<types::ModuleId>> codegen::CodeGenerator::topologically_sort_modules() const {
-{
-JaktInternal::Dictionary<size_t,i64> in_degrees = (TRY((Dictionary<size_t, i64>::create_with_entries({}))));
+(output += Jakt::DeprecatedString("} // namespace Jakt\n"sv));
+TRY((((result).set(Jakt::DeprecatedString("__unified_forward.h"sv),(Tuple{output, (((((compiler)->current_file_path()).value())).to_string())})))));
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> _magic = ((((((*this).program))->modules)).iterator());
+JaktInternal::ArrayIterator<bool> _magic = (((TRY((DynamicArray<bool>::create_with({true, false}))))).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<types::Module>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<bool> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<types::Module> module = (_magic_value.value());
+bool as_forward = (_magic_value.value());
 {
 {
-JaktInternal::ArrayIterator<types::ModuleId> _magic = ((((module)->imports)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(((sorted_modules).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
 for (;;){
-JaktInternal::Optional<types::ModuleId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ModuleId imported_module = (_magic_value.value());
+size_t idx = (_magic_value.value());
 {
-i64 const existing = ((in_degrees).get(((imported_module).id))).value_or_lazy_evaluated([&] { return static_cast<i64>(0LL); });
-TRY((((in_degrees).set(((imported_module).id),(JaktInternal::checked_add<i64>(existing,static_cast<i64>(1LL)))))));
-}
-
-}
-}
-
-if ((!(((in_degrees).contains(((((module)->id)).id)))))){
-TRY((((in_degrees).set(((((module)->id)).id),static_cast<i64>(0LL)))));
-}
+size_t const i = ((((sorted_modules)[(JaktInternal::checked_sub<size_t>(idx,static_cast<size_t>(1ULL)))])).id);
+if ((i == static_cast<size_t>(0ULL))){
+continue;
 }
-
+NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[i]);
+((((generator).compiler))->dbg_println(TRY((__jakt_format(Jakt::DeprecatedString("generate: module idx: {}, module.name {} - forward: {}"sv),i,((module)->name),as_forward)))));
+DeprecatedString const header_name = TRY((__jakt_format(Jakt::DeprecatedString("{}.h"sv),((module)->name))));
+DeprecatedString const impl_name = TRY((__jakt_format(Jakt::DeprecatedString("{}.cpp"sv),((module)->name))));
+if (as_forward){
+(output = Jakt::DeprecatedString("#pragma once\n"sv));
+(output += Jakt::DeprecatedString("#include \"__unified_forward.h\"\n"sv));
 }
+else {
+(output = TRY((__jakt_format(Jakt::DeprecatedString("#include \"{}\"\n"sv),header_name))));
 }
 
-JaktInternal::DynamicArray<types::ModuleId> stack = (TRY((DynamicArray<types::ModuleId>::create_with({}))));
+types::ScopeId const scope_id = types::ScopeId(((module)->id),static_cast<size_t>(0ULL));
+NonnullRefPtr<types::Scope> const scope = TRY((((((generator).program))->get_scope(scope_id))));
+if (as_forward){
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> _magic = ((((((*this).program))->modules)).iterator());
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<types::Module>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<types::Module> module = (_magic_value.value());
+types::ScopeId child_scope_id = (_magic_value.value());
 {
-if ((((in_degrees)[((((module)->id)).id)]) == static_cast<i64>(0LL))){
-TRY((((stack).push(((module)->id)))));
-}
-}
-
-}
+NonnullRefPtr<types::Scope> const scope = TRY((((((generator).program))->get_scope(child_scope_id))));
+if (((((scope)->import_path_if_extern)).has_value())){
+bool const has_name = ((((scope)->namespace_name)).has_value());
+if (has_name){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("namespace {} {{\n"sv),(((scope)->namespace_name).value())))));
 }
-
-JaktInternal::DynamicArray<types::ModuleId> sorted_modules = (TRY((DynamicArray<types::ModuleId>::create_with({}))));
-while ((!(((stack).is_empty())))){
-types::ModuleId const id = (((stack).pop()).value());
-TRY((((sorted_modules).push(id))));
 {
-JaktInternal::ArrayIterator<types::ModuleId> _magic = ((((((((((*this).program))->modules))[((id).id)]))->imports)).iterator());
+JaktInternal::ArrayIterator<parser::IncludeAction> _magic = ((((scope)->before_extern_include)).iterator());
 for (;;){
-JaktInternal::Optional<types::ModuleId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::IncludeAction> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ModuleId imported_module = (_magic_value.value());
+parser::IncludeAction action = (_magic_value.value());
 {
-i64 const module_in_degrees = ((in_degrees)[((imported_module).id)]);
-TRY((((in_degrees).set(((imported_module).id),(JaktInternal::checked_sub<i64>(module_in_degrees,static_cast<i64>(1LL)))))));
-if ((module_in_degrees == static_cast<i64>(1LL))){
-TRY((((stack).push(types::ModuleId(((imported_module).id))))));
-}
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>>>>{
+auto&& __jakt_match_variant = action;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::IncludeAction::Define>();DeprecatedString const& name = __jakt_match_value.name;
+DeprecatedString const& value = __jakt_match_value.value;
+{
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#ifdef {}\n"sv),name))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#undef {}\n"sv),name))));
+(output += Jakt::DeprecatedString("#endif\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#define {} {}\n"sv),name,value))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::IncludeAction::Undefine>();DeprecatedString const& name = __jakt_match_value.name;
+{
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#ifdef {}\n"sv),name))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#undef {}\n"sv),name))));
+(output += Jakt::DeprecatedString("#endif\n"sv));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
 }
 
-}
-if ((((sorted_modules).size()) == ((((((*this).program))->modules)).size()))){
-return (sorted_modules);
-}
-utility::panic(Jakt::DeprecatedString("Cyclic module imports"sv));
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_debug_description_getter(types::CheckedStruct const struct_,bool const is_inline) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((!(is_inline)) && (!(((((struct_).generic_parameters)).is_empty()))))){
-(output += Jakt::DeprecatedString("template <"sv));
-bool first = true;
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#include <{}>\n"sv),(((scope)->import_path_if_extern).value())))));
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<parser::IncludeAction> _magic = ((((scope)->after_extern_include)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::IncludeAction> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter param = (_magic_value.value());
+parser::IncludeAction action = (_magic_value.value());
 {
-if (first){
-(first = false);
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>>>>{
+auto&& __jakt_match_variant = action;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::IncludeAction::Define>();DeprecatedString const& name = __jakt_match_value.name;
+DeprecatedString const& value = __jakt_match_value.value;
+{
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#ifdef {}\n"sv),name))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#undef {}\n"sv),name))));
+(output += Jakt::DeprecatedString("#endif\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#define {} {}\n"sv),name,value))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::IncludeAction::Undefine>();DeprecatedString const& name = __jakt_match_value.name;
+{
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#ifdef {}\n"sv),name))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#undef {}\n"sv),name))));
+(output += Jakt::DeprecatedString("#endif\n"sv));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+}
+
+}
+}
+
+if (has_name){
+(output += ((Jakt::DeprecatedString(" } // namespace "sv) + (((scope)->namespace_name).value())) + Jakt::DeprecatedString("\n"sv)));
+}
+}
+}
+
+}
+}
+
+{
+JaktInternal::ArrayIterator<types::ModuleId> _magic = ((((module)->imports)).iterator());
+for (;;){
+JaktInternal::Optional<types::ModuleId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::ModuleId id = (_magic_value.value());
+{
+NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[((id).id)]);
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#include \"{}.h\"\n"sv),((module)->name)))));
+}
+
+}
+}
+
+}
+(output += Jakt::DeprecatedString("namespace Jakt {\n"sv));
+if ((!(((module)->is_root)))){
+TRY((((((generator).namespace_stack)).push(((module)->name)))));
+}
+(output += TRY((((generator).codegen_namespace(scope,module,as_forward)))));
+if ((!(((module)->is_root)))){
+JaktInternal::Optional<DeprecatedString> const dummy = ((((generator).namespace_stack)).pop());
+}
+(output += ((generator).deferred_output));
+(((generator).deferred_output) = Jakt::DeprecatedString(""sv));
+(output += Jakt::DeprecatedString("} // namespace Jakt\n"sv));
+if (as_forward){
+TRY((((result).set(header_name,(Tuple{output, ((module)->resolved_import_path)})))));
 }
 else {
-(output += Jakt::DeprecatedString(","sv));
+TRY((((result).set(impl_name,(Tuple{output, ((module)->resolved_import_path)})))));
 }
 
-(output += Jakt::DeprecatedString("typename "sv));
-(output += TRY((((*this).codegen_type(((param).type_id))))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(">\n"sv));
 }
-(output += Jakt::DeprecatedString("ErrorOr<DeprecatedString> "sv));
-if ((!(is_inline))){
-(output += TRY((((*this).codegen_type_possibly_as_namespace(((struct_).type_id),true)))));
-(output += Jakt::DeprecatedString("::"sv));
+
 }
-(output += Jakt::DeprecatedString("debug_description() const { "sv));
-(output += Jakt::DeprecatedString("auto builder = MUST(DeprecatedStringBuilder::create());"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.append(\"{}(\"sv));"sv),((struct_).name_for_codegen())))));
-(output += Jakt::DeprecatedString("{\n"sv));
-(output += Jakt::DeprecatedString("JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};\n"sv));
-size_t i = static_cast<size_t>(0ULL);
+}
+
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(((sorted_modules).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
 for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedField field = (_magic_value.value());
+size_t idx = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedVariable> const field_var = ((((*this).program))->get_variable(((field).variable_id)));
-(output += Jakt::DeprecatedString("TRY(JaktInternal::PrettyPrint::output_indentation(builder));"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.appendff(\"{}: "sv),((field_var)->name)))));
-if (((((*this).program))->is_string(((field_var)->type_id)))){
-(output += Jakt::DeprecatedString("\\\"{}\\\""sv));
+size_t const i = ((((sorted_modules)[(JaktInternal::checked_sub<size_t>(idx,static_cast<size_t>(1ULL)))])).id);
+NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[i]);
+DeprecatedString const header_name = TRY((__jakt_format(Jakt::DeprecatedString("{}.h"sv),((module)->name))));
+DeprecatedString const impl_name = TRY((__jakt_format(Jakt::DeprecatedString("{}_specializations.cpp"sv),((module)->name))));
+if ((i == static_cast<size_t>(0ULL))){
+(output = Jakt::DeprecatedString(""sv));
 }
 else {
-(output += Jakt::DeprecatedString("{}"sv));
+(output = TRY((__jakt_format(Jakt::DeprecatedString("#include \"{}\"\n"sv),header_name))));
 }
 
-if ((i != (JaktInternal::checked_sub<size_t>(((((struct_).fields)).size()),static_cast<size_t>(1ULL))))){
-(output += Jakt::DeprecatedString(", "sv));
+{
+JaktInternal::ArrayIterator<types::ModuleId> _magic = ((sorted_modules).iterator());
+for (;;){
+JaktInternal::Optional<types::ModuleId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-(output += Jakt::DeprecatedString("\", "sv));
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(((field_var)->type_id)));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = ((((((*this).program))->get_struct(struct_id))).record_type);
-switch(__jakt_match_variant.index()) {
-case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("*"sv));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-(output += (((field_var)->name) + Jakt::DeprecatedString("));\n"sv)));
-((i++));
+types::ModuleId id = (_magic_value.value());
+{
+if ((((id).id) == static_cast<size_t>(0ULL))){
+continue;
+}
+NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[((id).id)]);
+(output += TRY((__jakt_format(Jakt::DeprecatedString("#include \"{}.h\"\n"sv),((module)->name)))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString("}\n"sv));
-(output += Jakt::DeprecatedString("TRY(builder.append(\")\"sv));"sv));
-(output += Jakt::DeprecatedString("return builder.to_string();"sv));
-(output += Jakt::DeprecatedString(" }\n"sv));
+types::ScopeId const scope_id = types::ScopeId(((module)->id),static_cast<size_t>(0ULL));
+NonnullRefPtr<types::Scope> const scope = TRY((((((generator).program))->get_scope(scope_id))));
+(output += Jakt::DeprecatedString("namespace Jakt {\n"sv));
+if ((!(((module)->is_root)))){
+TRY((((((generator).namespace_stack)).push(((module)->name)))));
+}
+(output += TRY((((generator).codegen_namespace_specializations(scope,module)))));
+if ((!(((module)->is_root)))){
+JaktInternal::Optional<DeprecatedString> const dummy = ((((generator).namespace_stack)).pop());
+}
+(output += ((generator).deferred_output));
+(((generator).deferred_output) = Jakt::DeprecatedString(""sv));
+(output += Jakt::DeprecatedString("} // namespace Jakt\n"sv));
+TRY((((result).set(impl_name,(Tuple{output, ((module)->resolved_import_path)})))));
+}
+
+}
+}
+
+return (result);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_destructor(types::CheckedStruct const& struct_,NonnullRefPtr<types::CheckedFunction> const& function,bool const is_inline) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+DeprecatedString const qualified_name = TRY((((*this).codegen_type_possibly_as_namespace(((((struct_))).type_id),true))));
+if (((!(is_inline)) && (!(((((((struct_))).generic_parameters)).is_empty()))))){
+(output += Jakt::DeprecatedString("template <"sv));
+bool first = true;
+{
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((((struct_))).generic_parameters)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedGenericParameter param = (_magic_value.value());
+{
+if (first){
+(first = false);
+}
+else {
+(output += Jakt::DeprecatedString(","sv));
+}
+
+(output += Jakt::DeprecatedString("typename "sv));
+(output += TRY((((*this).codegen_type(((param).type_id))))));
+}
+
+}
+}
+
+(output += Jakt::DeprecatedString(">\n"sv));
+}
+if (is_inline){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("~{}()"sv),((((struct_))).name_for_codegen())))));
+}
+else {
+(output += TRY((__jakt_format(Jakt::DeprecatedString("{}::~{}()"sv),qualified_name,((((struct_))).name_for_codegen())))));
+}
+
+(output += TRY((((*this).codegen_block(((((function)))->block))))));
 return (output);
 }
 }
@@ -403,1310 +530,1504 @@ return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace(NonnullRefPtr<types::Scope> const scope,NonnullRefPtr<types::Module> const current_module,bool const as_forward) {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace_qualifier(types::ScopeId const scope_id,bool const skip_current,JaktInternal::Optional<DeprecatedString> const possible_constructor_name) const {
 {
-if ((((((scope)->alias_path)).has_value()) || ((((scope)->import_path_if_extern)).has_value()))){
-return (Jakt::DeprecatedString(""sv));
-}
-JaktInternal::Set<DeprecatedString> seen_types = (TRY((Set<DeprecatedString>::create_with_values({}))));
-if (as_forward){
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((((scope)->namespace_name)).has_value())){
-(output += ((Jakt::DeprecatedString("namespace "sv) + (((scope)->namespace_name).value())) + Jakt::DeprecatedString(" {\n"sv)));
+JaktInternal::Optional<types::ScopeId> current_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (skip_current);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((TRY((((((*this).program))->get_scope(scope_id)))))->parent));
 }
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const encoded_dependency_graph = TRY((((*this).produce_codegen_dependency_graph(scope))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> _magic = ((encoded_dependency_graph).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else {
+return JaktInternal::ExplicitValue(scope_id);
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> entry = (_magic_value.value());
+}()))
+;
+bool first = true;
+while (((current_scope_id).has_value())){
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope((current_scope_id.value())))));
+JaktInternal::Optional<DeprecatedString> const name = ((scope)->external_name).value_or_lazy_evaluated_optional([&] { return ((scope)->namespace_name); });
+bool const is_constructor_call = (first && (possible_constructor_name == name));
+ScopeGuard __jakt_var_544([&] {
 {
-JaktInternal::DynamicArray<types::TypeId> const traversal = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((*this).postorder_traversal(((entry).template get<0>()),seen_types,encoded_dependency_graph,traversal))));
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((traversal).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((name).has_value())){
+(first = false);
 }
-types::TypeId type_id = (_magic_value.value());
-{
-NonnullRefPtr<typename types::Type> const type_ = ((((*this).program))->get_type(type_id));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *type_;
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-{
-if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
-return JaktInternal::LoopContinue{};
+(current_scope_id = ((scope)->parent));
 }
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-DeprecatedString const enum_output = TRY((((*this).codegen_enum(enum_))));
-if ((!(((enum_output).is_empty())))){
-(output += enum_output);
+
+});
+if (((name).has_value())){
+if (is_constructor_call){
+continue;
 }
+(output = TRY((__jakt_format(Jakt::DeprecatedString("{}::{}"sv),(name.value()),output))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-{
-if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
-return JaktInternal::LoopContinue{};
 }
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-DeprecatedString const struct_output = TRY((((*this).codegen_struct(struct_))));
-if ((!(((struct_output).is_empty())))){
-(output += struct_output);
+return (output);
 }
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 26: {
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_checked_binary_op(NonnullRefPtr<typename types::CheckedExpression> const lhs,NonnullRefPtr<typename types::CheckedExpression> const rhs,parser::BinaryOperator const op,types::TypeId const type_id) {
 {
-}
-return JaktInternal::ExplicitValue<void>();
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += Jakt::DeprecatedString("JaktInternal::"sv));
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_add"sv));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_sub"sv));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_mul"sv));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_div"sv));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_mod"sv));
 };/*case end*/
 default: {
 {
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected type in dependency graph: {}"sv),type_))));
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Checked binary operation codegen is not supported for BinaryOperator::{}"sv),op))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-));
-TRY((((seen_types).add(TRY((((type_id).to_string())))))));
+)));
+(output += Jakt::DeprecatedString("<"sv));
+(output += TRY((((*this).codegen_type(type_id)))));
+(output += Jakt::DeprecatedString(">("sv));
+(output += TRY((((*this).codegen_expression(lhs)))));
+(output += Jakt::DeprecatedString(","sv));
+(output += TRY((((*this).codegen_expression(rhs)))));
+(output += Jakt::DeprecatedString(")"sv));
+return (output);
+}
 }
 
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_constructor_predecl(NonnullRefPtr<types::CheckedFunction> const function) {
+{
+types::TypeId const type_id = ((function)->return_type_id);
+NonnullRefPtr<typename types::Type> const type_ = ((((*this).program))->get_type(type_id));
+if (((type_)->index() == 23 /* Struct */)){
+types::StructId const struct_id = ((type_)->get<types::Type::Struct>()).value;
+types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
+if (((((structure).record_type)).index() == 1 /* Class */)){
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += Jakt::DeprecatedString("protected:\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("explicit {}("sv),((function)->name_for_codegen())))));
+bool first = true;
+{
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedParameter param = (_magic_value.value());
+{
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
+else {
+(first = false);
 }
 
+types::TypeId const param_type_id = ((((param).variable))->type_id);
+(output += TRY((((*this).codegen_type(param_type_id)))));
+(output += Jakt::DeprecatedString(" a_"sv));
+(output += ((((param).variable))->name));
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString(");\n"sv));
+DeprecatedString class_name_with_generics = Jakt::DeprecatedString(""sv);
+(class_name_with_generics += ((structure).name_for_codegen()));
+(first = true);
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((scope)->structs)).iterator());
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((structure).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::StructId> ___struct_id__ = (_magic_value.value());
+types::CheckedGenericParameter generic_parameter = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt_____struct_id__ = ___struct_id__;
-DeprecatedString const _ = ((jakt_____struct_id__).template get<0>());
-types::StructId const struct_id = ((jakt_____struct_id__).template get<1>());
-
-if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
-continue;
+if ((!(first))){
+(class_name_with_generics += Jakt::DeprecatedString(", "sv));
 }
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-if (((seen_types).contains(TRY((((((struct_).type_id)).to_string())))))){
-continue;
+else {
+(class_name_with_generics += Jakt::DeprecatedString("<"sv));
+(first = false);
 }
-(output += TRY((((*this).codegen_struct(struct_)))));
-(output += Jakt::DeprecatedString("\n"sv));
+
+(class_name_with_generics += TRY((((*this).codegen_type(((generic_parameter).type_id))))));
 }
 
 }
 }
 
+if ((!(((((structure).generic_parameters)).is_empty())))){
+(class_name_with_generics += Jakt::DeprecatedString(">"sv));
+}
+(output += Jakt::DeprecatedString("public:\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("static ErrorOr<NonnullRefPtr<{}>> __jakt_create"sv),class_name_with_generics))));
+(output += Jakt::DeprecatedString("("sv));
+(first = true);
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((scope)->enums)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::EnumId> ___enum_id__ = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt_____enum_id__ = ___enum_id__;
-DeprecatedString const _ = ((jakt_____enum_id__).template get<0>());
-types::EnumId const enum_id = ((jakt_____enum_id__).template get<1>());
-
-if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
-continue;
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-if (((seen_types).contains(TRY((((((enum_).type_id)).to_string())))))){
-continue;
+else {
+(first = false);
 }
-(output += TRY((((*this).codegen_enum(enum_)))));
-(output += Jakt::DeprecatedString("\n"sv));
+
+(output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
+(output += Jakt::DeprecatedString(" "sv));
+(output += ((((param).variable))->name));
 }
 
 }
 }
 
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(output += Jakt::DeprecatedString(");\n"sv));
+return (output);
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
-
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += ((function)->name_for_codegen()));
+(output += Jakt::DeprecatedString("("sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId function_id = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-if ((!(((((((function)->function_scope_id)).module_id)).equals(((current_module)->id)))))){
-continue;
-}
-if (((function)->is_comptime)){
-continue;
-}
-JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
-(((*this).current_function) = function);
-ScopeGuard __jakt_var_544([&] {
-(((*this).current_function) = previous_function);
-});
-if ((((((((function)->linkage)).index() == 1 /* External */) || ((((function)->type)).index() == 2 /* ImplicitConstructor */)) || ((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)) || ((((function)->type)).index() == 1 /* Destructor */))){
-continue;
-}
-if (((((((function)->generics))->params)).is_empty())){
-continue;
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
-if ((!(((((function)->specialization_index)).has_value())))){
-(output += TRY((((*this).codegen_function_predecl(function,false,true)))));
+else {
+(first = false);
 }
+
+(output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
+(output += Jakt::DeprecatedString(" a_"sv));
+(output += ((((param).variable))->name));
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString(");\n"sv));
+return (output);
+}
+else {
+utility::panic(Jakt::DeprecatedString("internal error: call to a constructor, but not a struct/class type"sv));
 }
 
 }
 }
 
+bool codegen::CodeGenerator::is_full_respecialization(JaktInternal::DynamicArray<types::TypeId> const type_args) const {
 {
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((type_args).iterator());
 for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ScopeId child_scope_id = (_magic_value.value());
+types::TypeId type_id = (_magic_value.value());
 {
-NonnullRefPtr<types::Scope> const child_scope = TRY((((((*this).program))->get_scope(child_scope_id))));
-if (((((child_scope)->namespace_name)).has_value())){
-DeprecatedString const name = (((child_scope)->namespace_name).value());
-TRY((((((*this).namespace_stack)).push(name))));
-(output += TRY((((*this).codegen_namespace(child_scope,current_module,as_forward)))));
-JaktInternal::Optional<DeprecatedString> const dummy = ((((*this).namespace_stack)).pop());
+if (((((((*this).program))->get_type(type_id)))->index() == 18 /* TypeVariable */)){
+return (false);
 }
 }
 
 }
 }
 
-if (((((scope)->namespace_name)).has_value())){
-(output += Jakt::DeprecatedString("}\n"sv));
-}
-return (output);
+return (true);
 }
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((((scope)->namespace_name)).has_value())){
-(output += ((Jakt::DeprecatedString("namespace "sv) + (((scope)->namespace_name).value())) + Jakt::DeprecatedString(" {\n"sv)));
 }
+
+ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>>> codegen::CodeGenerator::produce_codegen_dependency_graph(NonnullRefPtr<types::Scope> const scope) const {
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> dependency_graph = (TRY((Dictionary<DeprecatedString, JaktInternal::DynamicArray<DeprecatedString>>::create_with_entries({}))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::TypeId> _magic = ((((scope)->types)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::TypeId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::TypeId> type_ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
+TRY((((dependency_graph).set(TRY((((((type_).template get<1>())).to_string()))),TRY((((*this).extract_dependencies_from(((type_).template get<1>()),dependency_graph,true))))))));
+}
 
-{
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::FunctionId function_id = (_magic_value.value());
+}
+
+return (dependency_graph);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_statement(NonnullRefPtr<typename types::CheckedStatement> const statement) {
 {
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-if ((!(((((((function)->function_scope_id)).module_id)).equals(((current_module)->id)))))){
-continue;
+bool add_newline = true;
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((((((*this).debug_info)).statement_span_comments) && (((((statement)->span())).has_value()) && add_newline))){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("\n#line {}\n"sv),TRY((((((*this).debug_info)).span_to_source_location((((statement)->span()).value())))))))));
 }
-if (((function)->is_comptime)){
-continue;
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *statement;
+switch(__jakt_match_variant.index()) {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("return "sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(";"sv)));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((((*this).control_flow_state)).passes_through_match));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("return JaktInternal::LoopContinue{};"sv));
 }
-JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
-(((*this).current_function) = function);
-ScopeGuard __jakt_var_545([&] {
-(((*this).current_function) = previous_function);
-});
-if ((((((((function)->linkage)).index() == 1 /* External */) || ((((function)->type)).index() == 2 /* ImplicitConstructor */)) || ((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)) || ((((function)->type)).index() == 1 /* Destructor */))){
-continue;
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("continue;"sv));
 }
-if (((((((function)->generics))->params)).is_empty())){
-(output += TRY((((*this).codegen_function(function,false)))));
-(output += Jakt::DeprecatedString("\n"sv));
+}()))
+);
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((((*this).control_flow_state)).passes_through_match));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("return JaktInternal::LoopBreak{};"sv));
 }
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("break;"sv));
 }
+}()))
+);
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue((TRY((((*this).codegen_expression(expr)))) + Jakt::DeprecatedString(";"sv)));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.statement;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_545; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += Jakt::DeprecatedString("ScopeGuard "sv));
+(output += TRY((((*this).fresh_var()))));
+(output += Jakt::DeprecatedString("([&] {\n"sv));
+codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
+bool const old_inside_defer = ((*this).inside_defer);
+(((((*this).control_flow_state)).passes_through_match) = false);
+(((*this).inside_defer) = true);
+(output += TRY((((*this).codegen_statement(statement)))));
+(output += Jakt::DeprecatedString("});"sv));
+(((*this).control_flow_state) = last_control_flow);
+(((*this).inside_defer) = old_inside_defer);
+__jakt_var_545 = output; goto __jakt_label_480;
 
 }
+__jakt_label_480:; __jakt_var_545.release_value(); }));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((val).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("return ("sv) + TRY((((*this).codegen_expression((val.value())))))) + Jakt::DeprecatedString(");"sv)));
+}
+else {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_546; {
+__jakt_var_546 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = ((((((*this).current_function).value()))->can_throw));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("return {};"sv));
 }
-
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("return;"sv));
 }
+}()))
+; goto __jakt_label_481;
 
 }
+__jakt_label_481:; __jakt_var_546.release_value(); }));
 }
-
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((scope)->structs)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+}()))
+);
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_547; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((((((*this).debug_info)).statement_span_comments) && ((((statement)->span())).has_value()))){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("\n#line {}\n"sv),TRY((((((*this).debug_info)).span_to_source_location((((statement)->span()).value())))))))));
 }
-JaktInternal::Tuple<DeprecatedString,types::StructId> ___struct_id__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt_____struct_id__ = ___struct_id__;
-DeprecatedString const _ = ((jakt_____struct_id__).template get<0>());
-types::StructId const struct_id = ((jakt_____struct_id__).template get<1>());
+(output += Jakt::DeprecatedString("for (;;)"sv));
+(add_newline = false);
+codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
+(((*this).control_flow_state) = ((last_control_flow).enter_loop()));
+DeprecatedString const block_str = TRY((((*this).codegen_block(block))));
+(((*this).control_flow_state) = last_control_flow);
+(output += block_str);
+__jakt_var_547 = output; goto __jakt_label_482;
 
-if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
-continue;
-}
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-if (((((struct_).definition_linkage)).index() == 1 /* External */)){
-continue;
 }
-if ((!(((((struct_).generic_parameters)).is_empty())))){
-continue;
+__jakt_label_482:; __jakt_var_547.release_value(); }));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_548; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((((((*this).debug_info)).statement_span_comments) && ((((statement)->span())).has_value()))){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("\n#line {}\n"sv),TRY((((((*this).debug_info)).span_to_source_location((((statement)->span()).value())))))))));
 }
-(output += TRY((((*this).codegen_debug_description_getter(struct_,false)))));
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((struct_).scope_id)))));
+(output += Jakt::DeprecatedString("while ("sv));
+(output += TRY((((*this).codegen_expression(condition)))));
+(output += Jakt::DeprecatedString(")"sv));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
+(((*this).control_flow_state) = ((last_control_flow).enter_loop()));
+DeprecatedString const code = TRY((((*this).codegen_block(block))));
+(((*this).control_flow_state) = last_control_flow);
+(output += code);
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
+(add_newline = false);
+__jakt_var_548 = output; goto __jakt_label_483;
+
+}
+__jakt_label_483:; __jakt_var_548.release_value(); }));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_block(block)))));
+};/*case end*/
+case 14: {
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+utility::panic(Jakt::DeprecatedString("Garbage statement in codegen"sv));
+}
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& vars = __jakt_match_value.vars;
+NonnullRefPtr<typename types::CheckedStatement> const& var_decl = __jakt_match_value.var_decl;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_549; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += TRY((((*this).codegen_statement(var_decl)))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((vars).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId function_id = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedStatement> v = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
-(((*this).current_function) = function);
-ScopeGuard __jakt_var_546([&] {
-(((*this).current_function) = previous_function);
-});
-if (((((function)->type)).index() == 2 /* ImplicitConstructor */)){
-(output += TRY((((*this).codegen_constructor(function,false)))));
-(output += Jakt::DeprecatedString("\n"sv));
-}
-else if (((((function)->type)).index() == 1 /* Destructor */)){
-(output += TRY((((*this).codegen_destructor(((struct_)),((function)),false)))));
-(output += Jakt::DeprecatedString("\n"sv));
-}
-else if (((!(((((function)->type)).index() == 3 /* ImplicitEnumConstructor */))) && ((!(((function)->is_comptime))) && ((((((function)->generics))->params)).is_empty())))){
-(output += TRY((((*this).codegen_function_in_namespace(function,((struct_).type_id),false,false,JaktInternal::OptionalNone())))));
-(output += Jakt::DeprecatedString("\n"sv));
-}
+(output += TRY((((*this).codegen_statement(v)))));
 }
 
 }
 }
 
-}
+__jakt_var_549 = output; goto __jakt_label_484;
 
 }
+__jakt_label_484:; __jakt_var_549.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();types::VarId const& var_id = __jakt_match_value.var_id;
+NonnullRefPtr<typename types::CheckedExpression> const& init = __jakt_match_value.init;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_550; {
+NonnullRefPtr<types::CheckedVariable> const var = ((((*this).program))->get_variable(var_id));
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+NonnullRefPtr<typename types::Type> const var_type = ((((*this).program))->get_type(((var)->type_id)));
+(output += TRY((((*this).codegen_type(((var)->type_id))))));
+(output += Jakt::DeprecatedString(" "sv));
+if (((!(((var)->is_mutable))) && (!((((var_type)->index() == 27 /* Reference */) || ((var_type)->index() == 28 /* MutableReference */)))))){
+(output += Jakt::DeprecatedString("const "sv));
 }
+(output += ((var)->name));
+(output += Jakt::DeprecatedString(" = "sv));
+(output += TRY((((*this).codegen_expression(init)))));
+(output += Jakt::DeprecatedString(";"sv));
+__jakt_var_550 = output; goto __jakt_label_485;
 
 }
-
-}
-}
-
+__jakt_label_485:; __jakt_var_550.release_value(); }));
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::InlineCpp>();JaktInternal::DynamicArray<DeprecatedString> const& lines = __jakt_match_value.lines;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_551; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((scope)->enums)).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((lines).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::EnumId> ___enum_id__ = (_magic_value.value());
+DeprecatedString line = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt_____enum_id__ = ___enum_id__;
-DeprecatedString const _ = ((jakt_____enum_id__).template get<0>());
-types::EnumId const enum_id = ((jakt_____enum_id__).template get<1>());
+DeprecatedString escaped_line = line;
+(escaped_line = ((escaped_line).replace(Jakt::DeprecatedString("\\\""sv),Jakt::DeprecatedString("\""sv))));
+(escaped_line = ((escaped_line).replace(Jakt::DeprecatedString("\\\\"sv),Jakt::DeprecatedString("\\"sv))));
+(output += escaped_line);
+}
 
-if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
-continue;
 }
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-if (((((enum_).definition_linkage)).index() == 1 /* External */)){
-continue;
-}
-if ((!(((((enum_).generic_parameters)).is_empty())))){
-continue;
-}
-if (((((enum_).underlying_type_id)).equals(types::void_type_id()))){
-(output += TRY((((*this).codegen_enum_debug_description_getter(enum_,false)))));
-}
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((enum_).scope_id)))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
-{
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+__jakt_var_551 = output; goto __jakt_label_486;
+
 }
-types::FunctionId function_id = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
-(((*this).current_function) = function);
-ScopeGuard __jakt_var_547([&] {
-(((*this).current_function) = previous_function);
-});
-if (((!(((((function)->type)).index() == 2 /* ImplicitConstructor */))) && ((!(((((function)->type)).index() == 3 /* ImplicitEnumConstructor */))) && ((!(((((function)->type)).index() == 1 /* Destructor */))) && ((!(((function)->is_comptime))) && ((((((function)->generics))->params)).is_empty())))))){
-(output += TRY((((*this).codegen_function_in_namespace(function,((enum_).type_id),false,false,JaktInternal::OptionalNone())))));
-(output += Jakt::DeprecatedString("\n"sv));
+__jakt_label_486:; __jakt_var_551.release_value(); }));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& then_block = __jakt_match_value.then_block;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_552; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((((((*this).debug_info)).statement_span_comments) && ((((statement)->span())).has_value()))){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("\n#line {}\n"sv),TRY((((((*this).debug_info)).span_to_source_location((((statement)->span()).value())))))))));
+}
+(output += Jakt::DeprecatedString("if ("sv));
+(output += TRY((((*this).codegen_expression(condition)))));
+(output += Jakt::DeprecatedString(")"sv));
+(output += TRY((((*this).codegen_block(then_block)))));
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((else_statement).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue((Jakt::DeprecatedString("else "sv) + TRY((((*this).codegen_statement((else_statement.value())))))));
 }
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
+}()))
+);
+(add_newline = false);
+__jakt_var_552 = output; goto __jakt_label_487;
 
 }
+__jakt_label_487:; __jakt_var_552.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_553; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((((((*this).entered_yieldable_blocks)).size()) == static_cast<size_t>(0ULL))){
+utility::panic(Jakt::DeprecatedString("Must be in a block to yield"sv));
 }
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> const var_name_end_label_ = (((((*this).entered_yieldable_blocks)).last()).value());
+DeprecatedString const var_name = ((var_name_end_label_).template get<0>());
+DeprecatedString const end_label = ((var_name_end_label_).template get<1>());
 
-}
+(output += var_name);
+(output += Jakt::DeprecatedString(" = "sv));
+(output += TRY((((*this).codegen_expression(expr)))));
+(output += Jakt::DeprecatedString("; goto "sv));
+(output += end_label);
+(output += Jakt::DeprecatedString(";\n"sv));
+__jakt_var_553 = output; goto __jakt_label_488;
 
 }
+__jakt_label_488:; __jakt_var_553.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+if (add_newline){
+(output += Jakt::DeprecatedString("\n"sv));
 }
-
-}
-
+return (output);
 }
 }
 
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function_generic_parameters(NonnullRefPtr<types::CheckedFunction> const function) {
 {
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((!(((((((function)->generics))->params)).is_empty())))){
+(output += Jakt::DeprecatedString("template <"sv));
+bool first = true;
+{
+JaktInternal::ArrayIterator<types::FunctionGenericParameter> _magic = ((((((function)->generics))->params)).iterator());
 for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ScopeId child_scope_id = (_magic_value.value());
+types::FunctionGenericParameter generic_parameter = (_magic_value.value());
 {
-NonnullRefPtr<types::Scope> const child_scope = TRY((((((*this).program))->get_scope(child_scope_id))));
-if (((((child_scope)->namespace_name)).has_value())){
-DeprecatedString const name = (((child_scope)->namespace_name).value());
-TRY((((((*this).namespace_stack)).push(name))));
-(output += TRY((((*this).codegen_namespace(child_scope,current_module,as_forward)))));
-JaktInternal::Optional<DeprecatedString> const dummy = ((((*this).namespace_stack)).pop());
+if (first){
+(first = false);
+}
+else {
+(output += Jakt::DeprecatedString(","sv));
 }
+
+(output += Jakt::DeprecatedString("typename "sv));
+(output += TRY((((*this).codegen_type(((generic_parameter).type_id()))))));
 }
 
 }
 }
 
-if (((((scope)->namespace_name)).has_value())){
-(output += Jakt::DeprecatedString("}\n"sv));
+(output += Jakt::DeprecatedString(">\n"sv));
 }
 return (output);
 }
 }
 
-ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>>> codegen::CodeGenerator::produce_codegen_dependency_graph(NonnullRefPtr<types::Scope> const scope) const {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function_predecl(NonnullRefPtr<types::CheckedFunction> const function,bool const as_method,bool const allow_generics) {
 {
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> dependency_graph = (TRY((Dictionary<DeprecatedString, JaktInternal::DynamicArray<DeprecatedString>>::create_with_entries({}))));
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((allow_generics || (!(((((((function)->generics))->params)).is_empty())))) && ((((function)->linkage)).index() == 1 /* External */))){
+return (Jakt::DeprecatedString(""sv));
+}
+if (((function)->is_comptime)){
+return (Jakt::DeprecatedString(""sv));
+}
+if (((((function)->type)).index() == 2 /* ImplicitConstructor */)){
+return (Jakt::DeprecatedString(""sv));
+}
+if (((((function)->linkage)).index() == 1 /* External */)){
+(output += Jakt::DeprecatedString("extern "sv));
+}
+(output += TRY((((*this).codegen_function_generic_parameters(function)))));
+if (((((function)->return_type_id)).equals(types::never_type_id()))){
+(output += Jakt::DeprecatedString("[[noreturn]] "sv));
+}
+if ((((function)->name_for_codegen()) == Jakt::DeprecatedString("main"sv))){
+(output += Jakt::DeprecatedString("ErrorOr<int>"sv));
+}
+else {
+if ((as_method && ((function)->is_static()))){
+(output += Jakt::DeprecatedString("static "sv));
+}
+if (((function)->is_virtual)){
+(output += Jakt::DeprecatedString("virtual "sv));
+}
+DeprecatedString const naked_return_type = TRY((((*this).codegen_type(((function)->return_type_id)))));
+DeprecatedString const return_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((function)->can_throw));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),naked_return_type))));
+}
+else {
+return JaktInternal::ExplicitValue(naked_return_type);
+}
+}()))
+;
+(output += return_type);
+}
+
+(output += Jakt::DeprecatedString(" "sv));
+(output += ((function)->name_for_codegen()));
+(output += Jakt::DeprecatedString("("sv));
+bool first = true;
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::TypeId> _magic = ((((scope)->types)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::TypeId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::TypeId> type_ = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
-TRY((((dependency_graph).set(TRY((((((type_).template get<1>())).to_string()))),TRY((((*this).extract_dependencies_from(((type_).template get<1>()),dependency_graph,true))))))));
+if ((first && (((((param).variable))->name) == Jakt::DeprecatedString("this"sv)))){
+continue;
+}
+if (first){
+(first = false);
+}
+else {
+(output += Jakt::DeprecatedString(", "sv));
 }
 
+NonnullRefPtr<typename types::Type> const param_type = ((((*this).program))->get_type(((((param).variable))->type_id)));
+(output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
+(output += Jakt::DeprecatedString(" "sv));
+if (((!(((((param).variable))->is_mutable))) && (!((((param_type)->index() == 27 /* Reference */) || ((param_type)->index() == 28 /* MutableReference */)))))){
+(output += Jakt::DeprecatedString("const "sv));
 }
+(output += ((((param).variable))->name));
 }
 
-return (dependency_graph);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_unchecked_binary_op_assignment(NonnullRefPtr<typename types::CheckedExpression> const lhs,NonnullRefPtr<typename types::CheckedExpression> const rhs,parser::BinaryOperator const op,types::TypeId const type_id) {
+(output += Jakt::DeprecatedString(")"sv));
+if (((!(((function)->is_static()))) && (!(((function)->is_mutating()))))){
+(output += Jakt::DeprecatedString(" const"sv));
+}
+if (((function)->is_override)){
+(output += Jakt::DeprecatedString(" override"sv));
+}
+(output += Jakt::DeprecatedString(";"sv));
+(output += Jakt::DeprecatedString("\n"sv));
+return (output);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_match_body(types::CheckedMatchBody const body,types::TypeId const return_type_id) {
 {
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += Jakt::DeprecatedString("{"sv));
-(output += Jakt::DeprecatedString("auto& _jakt_ref = "sv));
-(output += TRY((((*this).codegen_expression(lhs)))));
-(output += Jakt::DeprecatedString(";"sv));
-(output += Jakt::DeprecatedString("_jakt_ref = static_cast<"sv));
-(output += TRY((((*this).codegen_type(type_id)))));
-(output += Jakt::DeprecatedString(">(_jakt_ref "sv));
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = op;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = body;
 switch(__jakt_match_variant.index()) {
-case 27: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" + "sv));
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" - "sv));
-};/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" * "sv));
-};/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" / "sv));
-};/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" % "sv));
-};/*case end*/
-default: {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Block>();
+types::CheckedBlock const& block = __jakt_match_value.value;
 {
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Checked binary operation assignment codegen is not supported for BinaryOperator::{}"sv),op))));
+(output += TRY((((*this).codegen_block(block)))));
+if ((((return_type_id).equals(types::void_type_id())) || ((return_type_id).equals(types::unknown_type_id())))){
+(output += Jakt::DeprecatedString("return JaktInternal::ExplicitValue<void>();\n"sv));
 }
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
-(output += TRY((((*this).codegen_expression(rhs)))));
-(output += Jakt::DeprecatedString(");"sv));
-(output += Jakt::DeprecatedString("}"sv));
-return (output);
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Expression>();
+NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.value;
+{
+if ((((((expr)->type())).equals(types::void_type_id())) || (((((expr)->type())).equals(types::unknown_type_id())) && (!(((expr)->index() == 25 /* OptionalNone */)))))){
+(output += Jakt::DeprecatedString("return ("sv));
+(output += TRY((((*this).codegen_expression(expr)))));
+(output += Jakt::DeprecatedString("), JaktInternal::ExplicitValue<void>();\n"sv));
 }
+else {
+(output += Jakt::DeprecatedString("return JaktInternal::ExplicitValue("sv));
+(output += TRY((((*this).codegen_expression(expr)))));
+(output += Jakt::DeprecatedString(");\n"sv));
 }
 
-ErrorOr<JaktInternal::Optional<DeprecatedString>> codegen::CodeGenerator::codegen_namespace_specialization(types::FunctionId const function_id,JaktInternal::Optional<types::TypeId> const containing_struct,NonnullRefPtr<types::Scope> const scope,NonnullRefPtr<types::Module> const current_module,bool const define_pass) {
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+return (output);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_ak_formatter(DeprecatedString const name,JaktInternal::DynamicArray<DeprecatedString> const generic_parameter_names) {
 {
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-if ((!(((((((function)->function_scope_id)).module_id)).equals(((current_module)->id)))))){
-return (JaktInternal::OptionalNone());
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+DeprecatedString const template_args = utility::join(TRY((utility::prepend_to_each(generic_parameter_names,Jakt::DeprecatedString("typename "sv)))),Jakt::DeprecatedString(", "sv));
+DeprecatedString const generic_type_args = utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv));
+DeprecatedString qualified_name = Jakt::DeprecatedString(""sv);
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((*this).namespace_stack)).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-if (((function)->is_comptime)){
-return (JaktInternal::OptionalNone());
+DeprecatedString namespace_ = (_magic_value.value());
+{
+(qualified_name += TRY((__jakt_format(Jakt::DeprecatedString("{}::"sv),namespace_))));
 }
-JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
-(((*this).current_function) = function);
-ScopeGuard __jakt_var_548([&] {
-(((*this).current_function) = previous_function);
-});
-if ((((((((function)->linkage)).index() == 1 /* External */) || ((((function)->type)).index() == 2 /* ImplicitConstructor */)) || ((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)) || ((((function)->type)).index() == 1 /* Destructor */))){
-return (JaktInternal::OptionalNone());
+
 }
-if ((((((((function)->generics))->params)).is_empty()) || (!(((((function)->specialization_index)).has_value()))))){
-return (JaktInternal::OptionalNone());
 }
-if ((((containing_struct).has_value()) && (!(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<JaktInternal::Optional<DeprecatedString>>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type((containing_struct.value())));
+
+(qualified_name += name);
+if ((!(((generic_parameter_names).is_empty())))){
+(qualified_name += TRY((__jakt_format(Jakt::DeprecatedString("<{}>\n"sv),generic_type_args))));
+}
+(output += Jakt::DeprecatedString("} // namespace Jakt\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>"sv),template_args))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("struct Jakt::Formatter<Jakt::{}> : Jakt::Formatter<Jakt::StringView>"sv),qualified_name))));
+(output += Jakt::DeprecatedString("{\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::{} const& value) {{\n"sv),qualified_name))));
+(output += Jakt::DeprecatedString("JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };"sv));
+(output += Jakt::DeprecatedString("Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));"sv));
+(output += Jakt::DeprecatedString("return format_error;"sv));
+(output += Jakt::DeprecatedString("}\n"sv));
+(output += Jakt::DeprecatedString("};\n"sv));
+return ((output + Jakt::DeprecatedString("namespace Jakt {\n"sv)));
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_method_call(NonnullRefPtr<typename types::CheckedExpression> const expr,types::CheckedCall const call,bool const is_optional) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((call).callee_throws)){
+(output += TRY((((*this).current_error_handler()))));
+(output += Jakt::DeprecatedString("(("sv));
+}
+DeprecatedString const object = TRY((((*this).codegen_expression_and_deref_if_generic_and_needed(expr))));
+(output += Jakt::DeprecatedString("(("sv));
+(output += object);
+(output += Jakt::DeprecatedString(")"sv));
+NonnullRefPtr<typename types::Type> const expression_type = ((((*this).program))->get_type(((expr)->type())));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *expression_type;
 switch(__jakt_match_variant.index()) {
+case 25: {
+{
+(output += Jakt::DeprecatedString("->"sv));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
 case 23: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((((((((*this).program))->get_struct(struct_id))).generic_parameters)).is_empty()));
+types::StructId const& id = __jakt_match_value.value;
+{
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
+if ((((((struct_).record_type)).index() == 1 /* Class */) && (object != Jakt::DeprecatedString("*this"sv)))){
+(output += Jakt::DeprecatedString("->"sv));
+}
+else {
+(output += Jakt::DeprecatedString("."sv));
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+{
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
+if ((((((struct_).record_type)).index() == 1 /* Class */) && (object != Jakt::DeprecatedString("*this"sv)))){
+(output += Jakt::DeprecatedString("->"sv));
+}
+else {
+(output += Jakt::DeprecatedString("."sv));
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 24: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& struct_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((((((((*this).program))->get_enum(struct_id))).generic_parameters)).is_empty()));
+types::EnumId const& id = __jakt_match_value.value;
+{
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(id));
+if ((((enum_).is_boxed) && (object != Jakt::DeprecatedString("*this"sv)))){
+(output += Jakt::DeprecatedString("->"sv));
+}
+else {
+(output += Jakt::DeprecatedString("."sv));
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(false);
+{
+(output += Jakt::DeprecatedString("."sv));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)))))){
-return (JaktInternal::OptionalNone());
-}
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-bool const is_full_respecialization = ((*this).is_full_respecialization(((((((function)->generics))->specializations))[(((function)->specialization_index).value())])));
-if ((define_pass && is_full_respecialization)){
-(output = Jakt::DeprecatedString("template<"sv));
-bool first = true;
+));
+if (is_optional){
+(output += Jakt::DeprecatedString("map([&](auto& _value) { return _value"sv));
+DeprecatedString access_operator = Jakt::DeprecatedString("."sv);
+if (((expression_type)->index() == 19 /* GenericInstance */)){
+JaktInternal::DynamicArray<types::TypeId> const args = ((expression_type)->get<types::Type::GenericInstance>()).args;
+if ((((args).size()) > static_cast<size_t>(0ULL))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(((args)[static_cast<i64>(0LL)])));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((((((((function)->generics))->specializations))[(((function)->specialization_index).value())])).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((((((((*this).program))->get_struct(id))).record_type)).index() == 1 /* Class */)){
+(access_operator = Jakt::DeprecatedString("->"sv));
 }
-types::TypeId arg = (_magic_value.value());
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
 {
-if (((((((*this).program))->get_type(arg)))->index() == 18 /* TypeVariable */)){
-DeprecatedString const name = ((((((*this).program))->get_type(arg)))->get<types::Type::TypeVariable>()).name;
-if (first){
-(first = false);
+if (((((((((*this).program))->get_struct(id))).record_type)).index() == 1 /* Class */)){
+(access_operator = Jakt::DeprecatedString("->"sv));
 }
-else {
-(output += Jakt::DeprecatedString(", "sv));
 }
-
-(output += TRY((__jakt_format(Jakt::DeprecatedString("typename {}"sv),name))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
-
 }
+(output += access_operator);
 }
-
-(output += Jakt::DeprecatedString(">\n"sv));
-(output += TRY((((*this).codegen_function_in_namespace(function,containing_struct,false,true,((((((function)->generics))->specializations))[(((function)->specialization_index).value())]))))));
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = ((call).type_args);
+if ((!(((generic_parameters).is_empty())))){
+(output += Jakt::DeprecatedString("template "sv));
 }
-else if (is_full_respecialization){
-JaktInternal::DynamicArray<DeprecatedString> args = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+(output += ((call).name_for_codegen()));
+if ((!(((generic_parameters).is_empty())))){
+JaktInternal::DynamicArray<DeprecatedString> types = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((((((((function)->generics))->specializations))[(((function)->specialization_index).value())])).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((generic_parameters).iterator());
 for (;;){
 JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId arg = (_magic_value.value());
+types::TypeId gen_param = (_magic_value.value());
 {
-TRY((((args).push(TRY((((*this).codegen_type(arg))))))));
+TRY((((types).push(TRY((((*this).codegen_type_possibly_as_namespace(gen_param,false))))))));
 }
 
 }
 }
 
-(output += TRY((__jakt_format(Jakt::DeprecatedString("\n/* specialisation {} of function {}: {} */"sv),(((function)->specialization_index).value()),((function)->name),args))));
-(output += Jakt::DeprecatedString("\ntemplate<> "sv));
-if (((((function)->return_type_id)).equals(types::never_type_id()))){
-(output += Jakt::DeprecatedString("[[noreturn]] "sv));
-}
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<JaktInternal::Optional<DeprecatedString>>>{
-auto __jakt_enum_value = (((function)->can_throw));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),TRY((((*this).codegen_type(((function)->return_type_id)))))))));
-}
-else {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(((function)->return_type_id))))));
-}
-}()))
-);
-(output += Jakt::DeprecatedString(" "sv));
-DeprecatedString const qualifier = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<JaktInternal::Optional<DeprecatedString>>>{
-auto __jakt_enum_value = (((containing_struct).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_type_possibly_as_namespace((containing_struct.value()),true)))));
-}
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-}
-}()))
-;
-if ((!(((qualifier).is_empty())))){
-(output += qualifier);
-(output += Jakt::DeprecatedString("::"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(types,Jakt::DeprecatedString(", "sv))))));
 }
-(output += ((function)->name_for_codegen()));
-(output += Jakt::DeprecatedString("<"sv));
+(output += Jakt::DeprecatedString("("sv));
 bool first = true;
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((((((((function)->generics))->specializations))[(((function)->specialization_index).value())])).iterator());
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
 for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId type_id = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> ___expr__ = (_magic_value.value());
 {
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const jakt_____expr__ = ___expr__;
+DeprecatedString const _ = ((jakt_____expr__).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const expr = ((jakt_____expr__).template get<1>());
+
 if (first){
 (first = false);
 }
 else {
-(output += Jakt::DeprecatedString(", "sv));
+(output += Jakt::DeprecatedString(","sv));
 }
 
-(output += TRY((((*this).codegen_type(type_id)))));
+(output += TRY((((*this).codegen_expression(expr)))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(">("sv));
-(first = true);
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(output += Jakt::DeprecatedString(")"sv));
+if (is_optional){
+(output += Jakt::DeprecatedString("; })"sv));
 }
-types::CheckedParameter param = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const variable = ((param).variable);
-if ((((variable)->name) == Jakt::DeprecatedString("this"sv))){
-continue;
+(output += Jakt::DeprecatedString(")"sv));
+if (((call).callee_throws)){
+(output += Jakt::DeprecatedString("))"sv));
 }
-if ((!(first))){
-(output += Jakt::DeprecatedString(","sv));
+return (output);
 }
-else {
-(first = false);
 }
 
-NonnullRefPtr<typename types::Type> const variable_type = ((((*this).program))->get_type(((variable)->type_id)));
-(output += TRY((((*this).codegen_type(((variable)->type_id))))));
-(output += Jakt::DeprecatedString(" "sv));
-if (((!(((variable)->is_mutable))) && (!((((variable_type)->index() == 27 /* Reference */) || ((variable_type)->index() == 28 /* MutableReference */)))))){
-(output += Jakt::DeprecatedString("const "sv));
+ErrorOr<DeprecatedString> codegen::CodeGenerator::fresh_label() {
+{
+return (TRY((__jakt_format(Jakt::DeprecatedString("__jakt_label_{}"sv),((((*this).fresh_label_counter)++))))));
 }
-(output += ((variable)->name));
 }
 
+ErrorOr<DeprecatedString> codegen::CodeGenerator::fresh_var() {
+{
+return (TRY((__jakt_format(Jakt::DeprecatedString("__jakt_var_{}"sv),((((*this).fresh_var_counter)++))))));
 }
 }
 
-(output += Jakt::DeprecatedString(")"sv));
-if (((!(((function)->is_static()))) && (!(((function)->is_mutating()))))){
-(output += Jakt::DeprecatedString(" const"sv));
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_call(types::CheckedCall const call) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((((((call).function_id)).has_value()) && ((((((*this).program))->get_function((((call).function_id).value()))))->is_comptime))){
+return (TRY((__jakt_format(Jakt::DeprecatedString("fail_comptime_call<{}, \"Comptime function {} called outside Jakt compiler\">()"sv),TRY((((*this).codegen_type(((call).return_type))))),((call).name)))));
 }
-(output += Jakt::DeprecatedString(";\n"sv));
+if (((call).callee_throws)){
+(output += TRY((((*this).current_error_handler()))));
+(output += Jakt::DeprecatedString("(("sv));
 }
-else {
-(output = TRY((__jakt_format(Jakt::DeprecatedString("\n/* specialisation {} of function {} omitted, not fully specialized: {} */\n"sv),(((function)->specialization_index).value()),((function)->name),((((((function)->generics))->specializations))[(((function)->specialization_index).value())])))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((call).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+{
+DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((call).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
 }
-
-return (output);
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace_specializations(NonnullRefPtr<types::Scope> const scope,NonnullRefPtr<types::Module> const current_module) {
-{
-if ((((((scope)->alias_path)).has_value()) || ((((scope)->import_path_if_extern)).has_value()))){
-return (Jakt::DeprecatedString(""sv));
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
 }
-JaktInternal::Set<DeprecatedString> seen_types = (TRY((Set<DeprecatedString>::create_with_values({}))));
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((((scope)->namespace_name)).has_value())){
-(output += ((Jakt::DeprecatedString("namespace "sv) + (((scope)->namespace_name).value())) + Jakt::DeprecatedString(" {\n"sv)));
+else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
 }
-{
-JaktInternal::ArrayIterator<bool> _magic = (((TRY((DynamicArray<bool>::create_with({false, true}))))).iterator());
-for (;;){
-JaktInternal::Optional<bool> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
-bool define_pass = (_magic_value.value());
-{
+}()))
+;
+(output += helper);
+(output += Jakt::DeprecatedString("("sv));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
+DeprecatedString const _ = ((__expr_).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
 
-{
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::FunctionId function_id = (_magic_value.value());
-{
-JaktInternal::Optional<DeprecatedString> const value = TRY((((*this).codegen_namespace_specialization(function_id,JaktInternal::OptionalNone(),scope,current_module,define_pass))));
-if (((value).has_value())){
-(output += (value.value()));
+(output += TRY((((*this).codegen_expression(expr)))));
+if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
+(output += Jakt::DeprecatedString(","sv));
 }
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString(")"sv));
 }
-
-}
+return JaktInternal::ExplicitValue<void>();
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((scope)->structs)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((call).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
 }
-JaktInternal::Tuple<DeprecatedString,types::StructId> ___struct_id__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt_____struct_id__ = ___struct_id__;
-DeprecatedString const _ = ((jakt_____struct_id__).template get<0>());
-types::StructId const struct_id = ((jakt_____struct_id__).template get<1>());
-
-if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
-continue;
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
 }
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-if (((seen_types).contains(TRY((((((struct_).type_id)).to_string())))))){
-continue;
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
 }
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((struct_).scope_id)))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
+}
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+}
+}()))
+;
+(output += helper);
+(output += Jakt::DeprecatedString("("sv));
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId function_id = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-JaktInternal::Optional<DeprecatedString> const value = TRY((((*this).codegen_namespace_specialization(function_id,((struct_).type_id),scope,current_module,define_pass))));
-if (((value).has_value())){
-(output += (value.value()));
-}
-}
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
+DeprecatedString const _ = ((__expr_).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
 
+(output += TRY((((*this).codegen_expression(expr)))));
+if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
+(output += Jakt::DeprecatedString(","sv));
 }
 }
 
+}
 }
 
+(output += Jakt::DeprecatedString(")"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+{
+DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((call).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
 }
-
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((scope)->enums)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
 }
-JaktInternal::Tuple<DeprecatedString,types::EnumId> ___enum_id__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt_____enum_id__ = ___enum_id__;
-DeprecatedString const _ = ((jakt_____enum_id__).template get<0>());
-types::EnumId const enum_id = ((jakt_____enum_id__).template get<1>());
-
-if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
-continue;
+else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
 }
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-if (((seen_types).contains(TRY((((((enum_).type_id)).to_string())))))){
-continue;
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((enum_).scope_id)))));
+}()))
+;
+(output += helper);
+(output += Jakt::DeprecatedString("("sv));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
+DeprecatedString const _ = ((__expr_).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
 
-{
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::FunctionId function_id = (_magic_value.value());
-{
-JaktInternal::Optional<DeprecatedString> const value = TRY((((*this).codegen_namespace_specialization(function_id,((enum_).type_id),scope,current_module,define_pass))));
-if (((value).has_value())){
-(output += (value.value()));
+(output += TRY((((*this).codegen_expression(expr)))));
+if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
+(output += Jakt::DeprecatedString(","sv));
 }
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString(")"sv));
 }
-
-}
-}
-
+return JaktInternal::ExplicitValue<void>();
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
+{
+DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((call).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
 }
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
-
+}()))
+;
+(output += helper);
+(output += Jakt::DeprecatedString("("sv));
 {
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
 for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ScopeId child_scope_id = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-NonnullRefPtr<types::Scope> const child_scope = TRY((((((*this).program))->get_scope(child_scope_id))));
-if (((((child_scope)->namespace_name)).has_value())){
-DeprecatedString const name = (((child_scope)->namespace_name).value());
-TRY((((((*this).namespace_stack)).push(name))));
-(output += TRY((((*this).codegen_namespace_specializations(child_scope,current_module)))));
-JaktInternal::Optional<DeprecatedString> const dummy = ((((*this).namespace_stack)).pop());
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
+DeprecatedString const _ = ((__expr_).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
+
+(output += TRY((((*this).codegen_expression(expr)))));
+if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
+(output += Jakt::DeprecatedString(","sv));
 }
 }
 
 }
 }
 
-if (((((scope)->namespace_name)).has_value())){
-(output += Jakt::DeprecatedString("}\n"sv));
-}
-return (output);
+(output += Jakt::DeprecatedString(")"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_expression_and_deref_if_generic_and_needed(NonnullRefPtr<typename types::CheckedExpression> const expression) {
+else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(((expression)->type())));
-switch(__jakt_match_variant.index()) {
-case 18: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_549; {
-DeprecatedString const contents = TRY((((*this).codegen_expression(expression))));
-__jakt_var_549 = TRY((__jakt_format(Jakt::DeprecatedString("(*([]<typename V>(V&& value) {{ if constexpr (IsSpecializationOf<V, NonnullRefPtr>) return &*value; else return &value; }})({}))"sv),contents))); goto __jakt_label_480;
-
+DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((call).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
 }
-__jakt_label_480:; __jakt_var_549.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_expression(expression)))));
-};/*case end*/
-}/*switch end*/
-}()
-)));
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum(types::CheckedEnum const enum_) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((!(((((enum_).underlying_type_id)).equals(types::void_type_id()))))){
-if (((((*this).program))->is_integer(((enum_).underlying_type_id)))){
-(output += ((((Jakt::DeprecatedString("enum class "sv) + ((enum_).name)) + Jakt::DeprecatedString(": "sv)) + TRY((((*this).codegen_type(((enum_).underlying_type_id)))))) + Jakt::DeprecatedString(" {\n"sv)));
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
+}
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+}
+}()))
+;
+(output += helper);
+(output += Jakt::DeprecatedString("("sv));
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
 for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& name = __jakt_match_value.name;
-NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue((((name + Jakt::DeprecatedString(" = "sv)) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(",\n"sv)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_550; {
-utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen_enum can't generate variant: {}"sv),variant))));
-__jakt_var_550 = Jakt::DeprecatedString(""sv); goto __jakt_label_481;
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
+DeprecatedString const _ = ((__expr_).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
 
+(output += TRY((((*this).codegen_expression(expr)))));
+if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
+(output += Jakt::DeprecatedString(","sv));
 }
-__jakt_label_481:; __jakt_var_550.release_value(); }));
-};/*case end*/
-}/*switch end*/
-}()
-)));
 }
 
 }
 }
 
-return ((output + Jakt::DeprecatedString("};\n"sv)));
-}
-else {
-utility::todo(Jakt::DeprecatedString("Enums with a non-integer underlying type"sv));
+(output += Jakt::DeprecatedString(")"sv));
 }
-
+return JaktInternal::ExplicitValue<void>();
 }
-bool const is_generic = (!(((((enum_).generic_parameters)).is_empty())));
-JaktInternal::DynamicArray<DeprecatedString> generic_parameter_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+else {
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((enum_).generic_parameters)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedGenericParameter generic_parameter = (_magic_value.value());
+bool close_enum_type_wrapper = false;
+if (((((call).function_id)).has_value())){
+types::FunctionId const function_id = (((call).function_id).value());
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+NonnullRefPtr<types::Module> const type_module = ((((*this).program))->get_module(((function_id).module)));
+if ((((((function)->type)).index() == 2 /* ImplicitConstructor */) || ((((function)->type)).index() == 4 /* ExternalClassConstructor */))){
+types::TypeId const type_id = ((call).return_type);
+NonnullRefPtr<typename types::Type> const type = ((((*this).program))->get_type(type_id));
+(output += TRY((((*this).codegen_namespace_path(call)))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *type;
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
 {
-if (((((((*this).program))->get_type(((generic_parameter).type_id))))->index() == 18 /* TypeVariable */)){
-DeprecatedString const name = ((((((*this).program))->get_type(((generic_parameter).type_id))))->get<types::Type::TypeVariable>()).name;
-TRY((((generic_parameter_names).push(name))));
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+if (((((struct_).record_type)).index() == 1 /* Class */)){
+(output += ((call).name_for_codegen()));
+(output += Jakt::DeprecatedString("::__jakt_create"sv));
 }
+else {
+(output += ((call).name_for_codegen()));
 }
 
 }
-}
-
-DeprecatedString template_args = utility::join(TRY((utility::prepend_to_each(generic_parameter_names,Jakt::DeprecatedString("typename "sv)))),Jakt::DeprecatedString(", "sv));
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> common_fields = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({}))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
+if (((((struct_).record_type)).index() == 1 /* Class */)){
+(output += TRY((((*this).codegen_namespace_qualifier(((struct_).scope_id),true,JaktInternal::OptionalNone())))));
+(output += ((struct_).name_for_codegen()));
+(output += Jakt::DeprecatedString("<"sv));
+bool first = true;
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedField field = (_magic_value.value());
+types::TypeId arg = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedVariable> const variable = ((((*this).program))->get_variable(((field).variable_id)));
-TRY((((common_fields).push((Tuple{((variable)->name), TRY((((*this).codegen_type(((variable)->type_id)))))})))));
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
-
+else {
+(first = false);
 }
+
+(output += TRY((((*this).codegen_type(arg)))));
 }
 
-(output += ((Jakt::DeprecatedString("namespace "sv) + ((enum_).name)) + Jakt::DeprecatedString("_Details {\n"sv)));
-{
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
-{
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const fields = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> __jakt_var_551; {
-if (is_generic){
-(output += ((Jakt::DeprecatedString("template<"sv) + template_args) + Jakt::DeprecatedString(">\n"sv)));
 }
-(output += ((Jakt::DeprecatedString("struct "sv) + name) + Jakt::DeprecatedString(" {\n"sv)));
-__jakt_var_551 = common_fields; goto __jakt_label_482;
 
+(output += Jakt::DeprecatedString(">::__jakt_create"sv));
 }
-__jakt_label_482:; __jakt_var_551.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<types::VarId> const& own_fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> __jakt_var_552; {
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> fields = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({}))));
+else {
+(output += ((call).name_for_codegen()));
+(output += Jakt::DeprecatedString("<"sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<types::VarId> _magic = ((own_fields).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
 for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::VarId field = (_magic_value.value());
+types::TypeId arg = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedVariable> const variable = ((((*this).program))->get_variable(field));
-TRY((((fields).push((Tuple{((variable)->name), TRY((((*this).codegen_type(((variable)->type_id)))))})))));
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
+}
+else {
+(first = false);
+}
+
+(output += TRY((((*this).codegen_type(arg)))));
 }
 
 }
 }
 
-if (is_generic){
-(output += ((Jakt::DeprecatedString("template<"sv) + template_args) + Jakt::DeprecatedString(">\n"sv)));
+(output += Jakt::DeprecatedString(">"sv));
 }
-(output += ((Jakt::DeprecatedString("struct "sv) + name) + Jakt::DeprecatedString(" {\n"sv)));
-__jakt_var_552 = fields; goto __jakt_label_483;
 
 }
-__jakt_label_483:; __jakt_var_552.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> __jakt_var_553; {
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> fields = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({}))));
+default: {
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> _magic = ((common_fields).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+utility::panic(Jakt::DeprecatedString("Should be unreachable"sv));
 }
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> field = (_magic_value.value());
-{
-TRY((((fields).push(field))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
-
+else if (((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(((function)->return_type_id)));
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+{
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+NonnullRefPtr<types::Module> const enum_type_module = ((((*this).program))->get_module(((enum_id).module)));
+if (((enum_).is_boxed)){
+(output += TRY((((*this).codegen_namespace_path(call)))));
+(output += Jakt::DeprecatedString("template __jakt_create<typename "sv));
+(output += TRY((((*this).codegen_type_possibly_as_namespace(((call).return_type),true)))));
+(output += ((Jakt::DeprecatedString("::"sv) + ((call).name_for_codegen())) + Jakt::DeprecatedString(">"sv)));
 }
+else {
+(output += (Jakt::DeprecatedString(" "sv) + TRY((((*this).codegen_type(((call).return_type)))))));
+(output += Jakt::DeprecatedString(" { "sv));
+(output += Jakt::DeprecatedString("typename "sv));
+(output += TRY((((*this).codegen_type_possibly_as_namespace(((call).return_type),true)))));
+(output += Jakt::DeprecatedString("::"sv));
+(output += ((call).name_for_codegen()));
+(close_enum_type_wrapper = true);
 }
 
-TRY((((fields).push((Tuple{Jakt::DeprecatedString("value"sv), TRY((((*this).codegen_type(type_id))))})))));
-if (is_generic){
-(output += ((Jakt::DeprecatedString("template<"sv) + template_args) + Jakt::DeprecatedString(">\n"sv)));
 }
-(output += ((Jakt::DeprecatedString("struct "sv) + name) + Jakt::DeprecatedString("{\n"sv)));
-__jakt_var_553 = fields; goto __jakt_label_484;
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+{
+utility::todo(Jakt::DeprecatedString("codegen generic enum instance"sv));
 }
-__jakt_label_484:; __jakt_var_553.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> __jakt_var_554; {
-utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen enum variant: {}"sv),variant))));
-__jakt_var_554 = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({})))); goto __jakt_label_485;
-
+{
+utility::panic(Jakt::DeprecatedString("constructor expected enum type"sv));
 }
-__jakt_label_485:; __jakt_var_554.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
+}
+else {
+(output += TRY((((*this).codegen_namespace_path(call)))));
+(output += ((call).name_for_codegen()));
+}
+
+}
+else {
+(output += TRY((((*this).codegen_namespace_path(call)))));
+(output += ((call).name_for_codegen()));
+}
+
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = ((call).type_args);
+if ((!(((generic_parameters).is_empty())))){
+JaktInternal::DynamicArray<DeprecatedString> types = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> _magic = ((fields).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((generic_parameters).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> name__type__ = (_magic_value.value());
+types::TypeId gen_param = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> const jakt__name__type__ = name__type__;
-DeprecatedString const name = ((jakt__name__type__).template get<0>());
-DeprecatedString const type = ((jakt__name__type__).template get<1>());
-
-(output += TRY((__jakt_format(Jakt::DeprecatedString("{} {};\n"sv),type,name))));
+TRY((((types).push(TRY((((*this).codegen_type_possibly_as_namespace(gen_param,false))))))));
 }
 
 }
 }
 
-if ((!(((fields).is_empty())))){
-(output += Jakt::DeprecatedString("template<"sv));
-JaktInternal::DynamicArray<DeprecatedString> generic_typenames = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-JaktInternal::DynamicArray<DeprecatedString> generic_argument_types = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-JaktInternal::DynamicArray<DeprecatedString> initializers = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(types,Jakt::DeprecatedString(", "sv))))));
+}
+JaktInternal::DynamicArray<DeprecatedString> arguments = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((fields).size()))});
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
 {
-TRY((((generic_typenames).push(TRY((__jakt_format(Jakt::DeprecatedString("typename _MemberT{}"sv),i)))))));
-TRY((((generic_argument_types).push(TRY((__jakt_format(Jakt::DeprecatedString("_MemberT{}&& member_{}"sv),i,i)))))));
-DeprecatedString initializer = (((((fields)[i])).template get<0>()) + Jakt::DeprecatedString("{ forward<_MemberT"sv));
-(initializer += (TRY((__jakt_format(Jakt::DeprecatedString("{}>(member_{}"sv),i,i))) + Jakt::DeprecatedString(")}"sv)));
-TRY((((initializers).push(initializer))));
+TRY((((arguments).push(TRY((((*this).codegen_expression(((arg).template get<1>())))))))));
 }
 
 }
 }
 
-(output += utility::join(generic_typenames,Jakt::DeprecatedString(", "sv)));
-(output += Jakt::DeprecatedString(">\n"sv));
-(output += (((((variant).name()) + Jakt::DeprecatedString("("sv)) + utility::join(generic_argument_types,Jakt::DeprecatedString(", "sv))) + Jakt::DeprecatedString("):\n"sv)));
-(output += (utility::join(initializers,Jakt::DeprecatedString(",\n"sv)) + Jakt::DeprecatedString("\n{}\n"sv)));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("({})"sv),utility::join(arguments,Jakt::DeprecatedString(","sv))))));
+if (close_enum_type_wrapper){
+(output += Jakt::DeprecatedString(" } "sv));
 }
-(output += Jakt::DeprecatedString("};\n"sv));
 }
-
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+if (((call).callee_throws)){
+(output += Jakt::DeprecatedString("))"sv));
+}
+return (output);
 }
 }
 
-(output += Jakt::DeprecatedString("}\n"sv));
-if (is_generic){
-(output += ((Jakt::DeprecatedString("template<"sv) + template_args) + Jakt::DeprecatedString(">\n"sv)));
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace_predecl(NonnullRefPtr<types::Scope> const scope,NonnullRefPtr<types::Module> const current_module) {
+{
+if ((((((scope)->alias_path)).has_value()) || ((((scope)->import_path_if_extern)).has_value()))){
+return (Jakt::DeprecatedString(""sv));
+}
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((((scope)->namespace_name)).has_value())){
+(output += Jakt::DeprecatedString("namespace "sv));
+(output += (((scope)->namespace_name).value()));
+(output += Jakt::DeprecatedString(" {\n"sv));
 }
-JaktInternal::DynamicArray<DeprecatedString> variant_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-JaktInternal::DynamicArray<DeprecatedString> variant_arguments_array = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((scope)->structs)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::StructId> ___struct_id__ = (_magic_value.value());
 {
-DeprecatedString argument = ((((enum_).name) + Jakt::DeprecatedString("_Details::"sv)) + ((variant).name()));
-if (is_generic){
-(argument += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv))))));
-}
-TRY((((variant_arguments_array).push(argument))));
-TRY((((variant_names).push(((variant).name())))));
-}
+JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt_____struct_id__ = ___struct_id__;
+DeprecatedString const _ = ((jakt_____struct_id__).template get<0>());
+types::StructId const struct_id = ((jakt_____struct_id__).template get<1>());
 
+if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
+continue;
 }
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+(output += TRY((((*this).codegen_struct_predecl(struct_)))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
 
-DeprecatedString const variant_args = utility::join(variant_arguments_array,Jakt::DeprecatedString(", "sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {} : public Variant<{}>"sv),((enum_).name),variant_args))));
-if (((enum_).is_boxed)){
-(output += TRY((__jakt_format(Jakt::DeprecatedString(", public RefCounted<{}"sv),((enum_).name)))));
-if (is_generic){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv))))));
 }
-(output += Jakt::DeprecatedString(">"sv));
 }
-(output += Jakt::DeprecatedString(" {\n"sv));
-(output += ((Jakt::DeprecatedString("using Variant<"sv) + variant_args) + Jakt::DeprecatedString(">::Variant;\n"sv)));
+
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((variant_names).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((scope)->enums)).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString name = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::EnumId> ___enum_id__ = (_magic_value.value());
 {
-(output += (((((Jakt::DeprecatedString("    using "sv) + name) + Jakt::DeprecatedString(" = "sv)) + ((enum_).name)) + Jakt::DeprecatedString("_Details::"sv)) + name));
-if (is_generic){
-(output += Jakt::DeprecatedString("<"sv));
-(output += utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv)));
-(output += Jakt::DeprecatedString(">"sv));
-}
-(output += Jakt::DeprecatedString(";\n"sv));
-}
+JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt_____enum_id__ = ___enum_id__;
+DeprecatedString const _ = ((jakt_____enum_id__).template get<0>());
+types::EnumId const enum_id = ((jakt_____enum_id__).template get<1>());
 
+if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
+continue;
 }
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+(output += TRY((((*this).codegen_enum_predecl(enum_)))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
 
-if (((enum_).is_boxed)){
-DeprecatedString fully_instantiated_name = ((enum_).name);
-if (is_generic){
-(fully_instantiated_name += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv))))));
-}
-(output += Jakt::DeprecatedString("template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {\n"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("return adopt_nonnull_ref_or_enomem(new (nothrow) {}(V(forward<Args>(args)...)));\n"sv),fully_instantiated_name))));
-(output += Jakt::DeprecatedString("}\n"sv));
-}
-if (((((enum_).generic_parameters)).is_empty())){
-(output += Jakt::DeprecatedString("ErrorOr<DeprecatedString> debug_description() const;\n"sv));
-}
-else {
-(output += TRY((((*this).codegen_enum_debug_description_getter(enum_,true)))));
 }
-
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> _magic = ((common_fields).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> field_name__type__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> const jakt__field_name__type__ = field_name__type__;
-DeprecatedString const field_name = ((jakt__field_name__type__).template get<0>());
-DeprecatedString const type = ((jakt__field_name__type__).template get<1>());
 
-(output += TRY((__jakt_format(Jakt::DeprecatedString("{} const& {}() const {{ switch(this->index()) {{"sv),type,field_name))));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((enum_).variants)).size()))});
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+types::ScopeId child = (_magic_value.value());
 {
-types::CheckedEnumVariant const variant = ((((enum_).variants))[i]);
-DeprecatedString const name = ((variant).name());
-(output += TRY((__jakt_format(Jakt::DeprecatedString("case {} /* {} */: "sv),i,name))));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("return this->template get<{}::{}>().{};\n"sv),((enum_).name),name,field_name))));
-}
-
-}
-}
-
-(output += Jakt::DeprecatedString("default: VERIFY_NOT_REACHED();\n"sv));
-(output += Jakt::DeprecatedString("}\n}\n"sv));
+(output += TRY((((*this).codegen_namespace_predecl(TRY((((((*this).program))->get_scope(child)))),current_module)))));
 }
 
 }
 }
 
-NonnullRefPtr<types::Scope> const enum_scope = TRY((((((*this).program))->get_scope(((enum_).scope_id)))));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((enum_scope)->functions)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
 for (;;){
 JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
@@ -1727,24 +2048,22 @@ break;
 }
 types::FunctionId function_id = (_magic_value.value());
 {
+if ((!(((((function_id).module)).equals(((current_module)->id)))))){
+continue;
+}
 NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+if (((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)){
+continue;
+}
 JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function_id = ((*this).current_function);
 (((*this).current_function) = static_cast<JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>>>(function));
-ScopeGuard __jakt_var_555([&] {
+ScopeGuard __jakt_var_554([&] {
 (((*this).current_function) = previous_function_id);
 });
-if ((!(((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)))){
-if ((!(((((enum_).generic_parameters)).is_empty())))){
-(output += TRY((((*this).codegen_function(function,true)))));
-}
-else if ((((((((function)->generics))->params)).is_empty()) || (!(((((function)->specialization_index)).has_value()))))){
-(output += TRY((((*this).codegen_function_predecl(function,true,false)))));
-}
-}
-else {
-continue;
+if (((!(((((function)->type)).index() == 2 /* ImplicitConstructor */))) && ((!(((((function)->type)).index() == 1 /* Destructor */))) && ((((function)->name_for_codegen()) != Jakt::DeprecatedString("main"sv)) && ((((((function)->generics))->params)).is_empty()))))){
+(output += TRY((((*this).codegen_function_predecl(function,false,false)))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
-
 }
 
 }
@@ -1755,83 +2074,143 @@ continue;
 }
 }
 
-(output += Jakt::DeprecatedString("};\n"sv));
-(((*this).deferred_output) += TRY((((*this).codegen_ak_formatter(((enum_).name),generic_parameter_names)))));
+if (((((scope)->namespace_name)).has_value())){
+(output += Jakt::DeprecatedString("}\n"sv));
+}
 return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_struct_type(types::StructId const id,bool const as_namespace) const {
+ErrorOr<JaktInternal::DynamicArray<types::ModuleId>> codegen::CodeGenerator::topologically_sort_modules() const {
 {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-NonnullRefPtr<types::Module> const type_module = ((((*this).program))->get_module(((id).module)));
-types::CheckedStruct const checked_struct = ((((*this).program))->get_struct(id));
-if (((!(as_namespace)) && ((((checked_struct).record_type)).index() == 1 /* Class */))){
-(output += Jakt::DeprecatedString("NonnullRefPtr<"sv));
-(output += TRY((((*this).codegen_namespace_qualifier(((checked_struct).scope_id),true,JaktInternal::OptionalNone())))));
-(output += ((checked_struct).name_for_codegen()));
-(output += Jakt::DeprecatedString(">"sv));
+JaktInternal::Dictionary<size_t,i64> in_degrees = (TRY((Dictionary<size_t, i64>::create_with_entries({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> _magic = ((((((*this).program))->modules)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<types::Module>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-(output += TRY((((*this).codegen_namespace_qualifier(((checked_struct).scope_id),true,JaktInternal::OptionalNone())))));
-(output += ((checked_struct).name_for_codegen()));
+NonnullRefPtr<types::Module> module = (_magic_value.value());
+{
+{
+JaktInternal::ArrayIterator<types::ModuleId> _magic = ((((module)->imports)).iterator());
+for (;;){
+JaktInternal::Optional<types::ModuleId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::ModuleId imported_module = (_magic_value.value());
+{
+i64 const existing = ((in_degrees).get(((imported_module).id))).value_or_lazy_evaluated([&] { return static_cast<i64>(0LL); });
+TRY((((in_degrees).set(((imported_module).id),(JaktInternal::checked_add<i64>(existing,static_cast<i64>(1LL)))))));
 }
 
-return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_struct_predecl(types::CheckedStruct const struct_) {
+if ((!(((in_degrees).contains(((((module)->id)).id)))))){
+TRY((((in_degrees).set(((((module)->id)).id),static_cast<i64>(0LL)))));
+}
+}
+
+}
+}
+
+JaktInternal::DynamicArray<types::ModuleId> stack = (TRY((DynamicArray<types::ModuleId>::create_with({}))));
 {
-if (((((struct_).definition_linkage)).index() == 1 /* External */)){
-return (Jakt::DeprecatedString(""sv));
+JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> _magic = ((((((*this).program))->modules)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<types::Module>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((!(((((struct_).generic_parameters)).is_empty())))){
-(output += Jakt::DeprecatedString("template <"sv));
-bool first = true;
+NonnullRefPtr<types::Module> module = (_magic_value.value());
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
+if ((((in_degrees)[((((module)->id)).id)]) == static_cast<i64>(0LL))){
+TRY((((stack).push(((module)->id)))));
+}
+}
+
+}
+}
+
+JaktInternal::DynamicArray<types::ModuleId> sorted_modules = (TRY((DynamicArray<types::ModuleId>::create_with({}))));
+while ((!(((stack).is_empty())))){
+types::ModuleId const id = (((stack).pop()).value());
+TRY((((sorted_modules).push(id))));
+{
+JaktInternal::ArrayIterator<types::ModuleId> _magic = ((((((((((*this).program))->modules))[((id).id)]))->imports)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::ModuleId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter generic_parameter = (_magic_value.value());
+types::ModuleId imported_module = (_magic_value.value());
 {
-if (first){
-(first = false);
+i64 const module_in_degrees = ((in_degrees)[((imported_module).id)]);
+TRY((((in_degrees).set(((imported_module).id),(JaktInternal::checked_sub<i64>(module_in_degrees,static_cast<i64>(1LL)))))));
+if ((module_in_degrees == static_cast<i64>(1LL))){
+TRY((((stack).push(types::ModuleId(((imported_module).id))))));
 }
-else {
-(output += Jakt::DeprecatedString(","sv));
 }
 
-(output += Jakt::DeprecatedString("typename "sv));
-(output += TRY((((*this).codegen_type(((generic_parameter).type_id))))));
+}
 }
 
+}
+if ((((sorted_modules).size()) == ((((((*this).program))->modules)).size()))){
+return (sorted_modules);
+}
+utility::panic(Jakt::DeprecatedString("Cyclic module imports"sv));
 }
 }
 
-(output += Jakt::DeprecatedString(">"sv));
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_block(types::CheckedBlock const block) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((((block).yielded_type)).has_value())){
+types::TypeId const yielded_type = (((block).yielded_type).value());
+DeprecatedString const type_output = TRY((((*this).codegen_type(yielded_type))));
+DeprecatedString const fresh_var = TRY((((*this).fresh_var())));
+DeprecatedString const fresh_label = TRY((((*this).fresh_label())));
+TRY((((((*this).entered_yieldable_blocks)).push((Tuple{fresh_var, fresh_label})))));
+(output += Jakt::DeprecatedString("({ Optional<"sv));
+(output += type_output);
+(output += Jakt::DeprecatedString("> "sv));
+(output += fresh_var);
+(output += Jakt::DeprecatedString("; "sv));
+}
+(output += Jakt::DeprecatedString("{\n"sv));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+{
+(output += TRY((((*this).codegen_statement(statement)))));
+}
+
+}
+}
+
+(output += Jakt::DeprecatedString("}\n"sv));
+if (((((block).yielded_type)).has_value())){
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> const var_label_ = (((((*this).entered_yieldable_blocks)).pop()).value());
+DeprecatedString const var = ((var_label_).template get<0>());
+DeprecatedString const label = ((var_label_).template get<1>());
+
+(output += label);
+(output += Jakt::DeprecatedString(":; "sv));
+(output += var);
+if ((!(((block).yielded_none)))){
+(output += Jakt::DeprecatedString(".release_value()"sv));
+}
+(output += Jakt::DeprecatedString("; })"sv));
 }
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = ((struct_).record_type);
-switch(__jakt_match_variant.index()) {
-case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("class "sv));
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("struct "sv));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-(output += ((struct_).name_for_codegen()));
-(output += Jakt::DeprecatedString(";"sv));
 return (output);
 }
 }
@@ -2075,1404 +2454,378 @@ return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_checked_binary_op(NonnullRefPtr<typename types::CheckedExpression> const lhs,NonnullRefPtr<typename types::CheckedExpression> const rhs,parser::BinaryOperator const op,types::TypeId const type_id) {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_debug_description_getter(types::CheckedStruct const struct_,bool const is_inline) {
 {
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += Jakt::DeprecatedString("JaktInternal::"sv));
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_add"sv));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_sub"sv));
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_mul"sv));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_div"sv));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_mod"sv));
-};/*case end*/
-default: {
-{
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Checked binary operation codegen is not supported for BinaryOperator::{}"sv),op))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
-(output += Jakt::DeprecatedString("<"sv));
-(output += TRY((((*this).codegen_type(type_id)))));
-(output += Jakt::DeprecatedString(">("sv));
-(output += TRY((((*this).codegen_expression(lhs)))));
-(output += Jakt::DeprecatedString(","sv));
-(output += TRY((((*this).codegen_expression(rhs)))));
-(output += Jakt::DeprecatedString(")"sv));
-return (output);
-}
-}
-
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> codegen::CodeGenerator::extract_dependencies_from_enum(types::EnumId const enum_id,JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph,bool const top_level) const {
-{
-JaktInternal::DynamicArray<DeprecatedString> dependencies = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-if (((((enum_).definition_linkage)).index() == 1 /* External */)){
-return (dependencies);
-}
-if ((((enum_).is_boxed) && (!(top_level)))){
-return (dependencies);
-}
-TRY((((dependencies).push(TRY((((((enum_).type_id)).to_string())))))));
-if ((!(((((enum_).underlying_type_id)).equals(types::unknown_type_id()))))){
-JaktInternal::DynamicArray<DeprecatedString> const inner_dependencies = TRY((((*this).extract_dependencies_from(((enum_).underlying_type_id),dependency_graph,false))));
+if (((!(is_inline)) && (!(((((struct_).generic_parameters)).is_empty()))))){
+(output += Jakt::DeprecatedString("template <"sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((inner_dependencies).iterator());
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString dependency = (_magic_value.value());
+types::CheckedGenericParameter param = (_magic_value.value());
 {
-TRY((((dependencies).push(dependency))));
+if (first){
+(first = false);
+}
+else {
+(output += Jakt::DeprecatedString(","sv));
+}
+
+(output += Jakt::DeprecatedString("typename "sv));
+(output += TRY((((*this).codegen_type(((param).type_id))))));
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString(">\n"sv));
 }
-{
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(output += Jakt::DeprecatedString("ErrorOr<DeprecatedString> "sv));
+if ((!(is_inline))){
+(output += TRY((((*this).codegen_type_possibly_as_namespace(((struct_).type_id),true)))));
+(output += Jakt::DeprecatedString("::"sv));
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<DeprecatedString>>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();types::TypeId const& type_id = __jakt_match_value.type_id;
-{
-JaktInternal::DynamicArray<DeprecatedString> const inner_dependencies = TRY((((*this).extract_dependencies_from(type_id,dependency_graph,false))));
+(output += Jakt::DeprecatedString("debug_description() const { "sv));
+(output += Jakt::DeprecatedString("auto builder = MUST(DeprecatedStringBuilder::create());"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.append(\"{}(\"sv));"sv),((struct_).name_for_codegen())))));
+(output += Jakt::DeprecatedString("{\n"sv));
+(output += Jakt::DeprecatedString("JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};\n"sv));
+size_t i = static_cast<size_t>(0ULL);
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((inner_dependencies).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString dependency = (_magic_value.value());
+types::CheckedField field = (_magic_value.value());
 {
-TRY((((dependencies).push(dependency))));
-}
-
+NonnullRefPtr<types::CheckedVariable> const field_var = ((((*this).program))->get_variable(((field).variable_id)));
+(output += Jakt::DeprecatedString("TRY(JaktInternal::PrettyPrint::output_indentation(builder));"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.appendff(\"{}: "sv),((field_var)->name)))));
+if (((((*this).program))->is_string(((field_var)->type_id)))){
+(output += Jakt::DeprecatedString("\\\"{}\\\""sv));
 }
+else {
+(output += Jakt::DeprecatedString("{}"sv));
 }
 
+if ((i != (JaktInternal::checked_sub<size_t>(((((struct_).fields)).size()),static_cast<size_t>(1ULL))))){
+(output += Jakt::DeprecatedString(", "sv));
 }
-return JaktInternal::ExplicitValue<void>();
+(output += Jakt::DeprecatedString("\", "sv));
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(((field_var)->type_id)));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = ((((((*this).program))->get_struct(struct_id))).record_type);
+switch(__jakt_match_variant.index()) {
+case 1: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("*"sv));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
+default: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+(output += (((field_var)->name) + Jakt::DeprecatedString("));\n"sv)));
+((i++));
+}
+
+}
+}
+
+(output += Jakt::DeprecatedString("}\n"sv));
+(output += Jakt::DeprecatedString("TRY(builder.append(\")\"sv));"sv));
+(output += Jakt::DeprecatedString("return builder.to_string();"sv));
+(output += Jakt::DeprecatedString(" }\n"sv));
+return (output);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_lambda_block(bool const can_throw,types::CheckedBlock const block,types::TypeId const return_type_id) {
+{
+DeprecatedString output = Jakt::DeprecatedString("{\n"sv);
+(output += TRY((((*this).codegen_block(block)))));
+if ((can_throw && ((return_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } ))))){
+(output += Jakt::DeprecatedString("return {};\n"sv));
+}
+(output += Jakt::DeprecatedString("}\n"sv));
+return (output);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_match(NonnullRefPtr<typename types::CheckedExpression> const expr,JaktInternal::DynamicArray<types::CheckedMatchCase> const match_cases,types::TypeId const type_id,bool const all_variants_constant) {
+{
+codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
+(((*this).control_flow_state) = ((((*this).control_flow_state)).enter_match()));
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+NonnullRefPtr<typename types::Type> const expr_type = ((((*this).program))->get_type(((expr)->type())));
+if (((expr_type)->index() == 24 /* Enum */)){
+types::EnumId const enum_id = ((expr_type)->get<types::Type::Enum>()).value;
+(output += TRY((((*this).codegen_enum_match(((((*this).program))->get_enum(enum_id)),expr,match_cases,type_id,all_variants_constant)))));
+}
+else {
+(output += TRY((((*this).codegen_generic_match(expr,match_cases,type_id,all_variants_constant)))));
+}
+
+(((*this).control_flow_state) = last_control_flow);
+return (output);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace_specializations(NonnullRefPtr<types::Scope> const scope,NonnullRefPtr<types::Module> const current_module) {
 {
+if ((((((scope)->alias_path)).has_value()) || ((((scope)->import_path_if_extern)).has_value()))){
+return (Jakt::DeprecatedString(""sv));
+}
+JaktInternal::Set<DeprecatedString> seen_types = (TRY((Set<DeprecatedString>::create_with_values({}))));
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((((scope)->namespace_name)).has_value())){
+(output += ((Jakt::DeprecatedString("namespace "sv) + (((scope)->namespace_name).value())) + Jakt::DeprecatedString(" {\n"sv)));
+}
 {
-JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
+JaktInternal::ArrayIterator<bool> _magic = (((TRY((DynamicArray<bool>::create_with({false, true}))))).iterator());
 for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<bool> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::VarId field = (_magic_value.value());
+bool define_pass = (_magic_value.value());
 {
-types::TypeId const type_id = ((((((*this).program))->get_variable(field)))->type_id);
-JaktInternal::DynamicArray<DeprecatedString> const inner_dependencies = TRY((((*this).extract_dependencies_from(type_id,dependency_graph,false))));
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((inner_dependencies).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString dependency = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-TRY((((dependencies).push(dependency))));
-}
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+types::FunctionId function_id = (_magic_value.value());
+{
+JaktInternal::Optional<DeprecatedString> const value = TRY((((*this).codegen_namespace_specialization(function_id,JaktInternal::OptionalNone(),scope,current_module,define_pass))));
+if (((value).has_value())){
+(output += (value.value()));
 }
-
 }
 
 }
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
 }
 
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((scope)->structs)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-}
+JaktInternal::Tuple<DeprecatedString,types::StructId> ___struct_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt_____struct_id__ = ___struct_id__;
+DeprecatedString const _ = ((jakt_____struct_id__).template get<0>());
+types::StructId const struct_id = ((jakt_____struct_id__).template get<1>());
 
-return (dependencies);
+if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
+continue;
 }
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+if (((seen_types).contains(TRY((((((struct_).type_id)).to_string())))))){
+continue;
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_expression(NonnullRefPtr<typename types::CheckedExpression> const expression) {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *expression;
-switch(__jakt_match_variant.index()) {
-case 33: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Reflect>();utility::Span const& span = __jakt_match_value.span;
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((struct_).scope_id)))));
 {
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected reflect expression at {}"sv),span))));
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& from = __jakt_match_value.from;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& to = __jakt_match_value.to;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_556; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-NonnullRefPtr<typename types::Type> const type = ((((*this).program))->get_type(type_id));
-types::TypeId const index_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *type;
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(((args)[static_cast<i64>(0LL)]));
-};/*case end*/
-default: {
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-utility::panic(Jakt::DeprecatedString("Internal error: range expression doesn't have Range type"sv));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
+
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-(output += Jakt::DeprecatedString("("sv));
-(output += TRY((((*this).codegen_type(type_id)))));
-(output += Jakt::DeprecatedString("{"sv));
-(output += Jakt::DeprecatedString("static_cast<"sv));
-(output += TRY((((*this).codegen_type(index_type)))));
-(output += Jakt::DeprecatedString(">("sv));
-if (((from).has_value())){
-(output += TRY((((*this).codegen_expression((from.value()))))));
+types::FunctionId function_id = (_magic_value.value());
+{
+JaktInternal::Optional<DeprecatedString> const value = TRY((((*this).codegen_namespace_specialization(function_id,((struct_).type_id),scope,current_module,define_pass))));
+if (((value).has_value())){
+(output += (value.value()));
 }
-else {
-(output += Jakt::DeprecatedString("0LL"sv));
 }
 
-(output += Jakt::DeprecatedString("),static_cast<"sv));
-(output += TRY((((*this).codegen_type(index_type)))));
-(output += Jakt::DeprecatedString(">("sv));
-if (((to).has_value())){
-(output += TRY((((*this).codegen_expression((to.value()))))));
 }
-else {
-(output += Jakt::DeprecatedString("9223372036854775807LL"sv));
 }
 
-(output += Jakt::DeprecatedString(")})"sv));
-__jakt_var_556 = output; goto __jakt_label_486;
-
 }
-__jakt_label_486:; __jakt_var_556.release_value(); }));
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("JaktInternal::OptionalNone()"sv));
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalSome>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(((((Jakt::DeprecatedString("static_cast<"sv) + TRY((((*this).codegen_type(type_id))))) + Jakt::DeprecatedString(">("sv)) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(")"sv)));
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(".value())"sv)));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::QuotedString>();types::CheckedStringLiteral const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_557; {
-DeprecatedString const original_string = ((val).to_string());
-DeprecatedString const escaped_value = ((original_string).replace(Jakt::DeprecatedString("\n"sv),Jakt::DeprecatedString("\\n"sv)));
-__jakt_var_557 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((((val).type_id)).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ))));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("Jakt::DeprecatedString(\""sv) + escaped_value) + Jakt::DeprecatedString("\"sv)"sv)));
+
 }
-else {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_558; {
-DeprecatedString const error_handler = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((val).may_throw));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("TRY"sv));
 }
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+
 }
-}()))
-;
-__jakt_var_558 = TRY((__jakt_format(Jakt::DeprecatedString("{}({}::from_string_literal(\"{}\"sv))"sv),error_handler,TRY((((*this).codegen_type(((val).type_id))))),escaped_value))); goto __jakt_label_488;
 
 }
-__jakt_label_488:; __jakt_var_558.release_value(); }));
 }
-}()))
-; goto __jakt_label_487;
 
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((scope)->enums)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_487:; __jakt_var_557.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ByteConstant>();DeprecatedString const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("'"sv) + val) + Jakt::DeprecatedString("'"sv)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CCharacterConstant>();DeprecatedString const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("'"sv) + val) + Jakt::DeprecatedString("'"sv)));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CharacterConstant>();DeprecatedString const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("static_cast<u32>(U'"sv) + val) + Jakt::DeprecatedString("')"sv)));
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((var)->name));
-if (__jakt_enum_value == Jakt::DeprecatedString("this"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("*this"sv));
-}
-else {
-return JaktInternal::ExplicitValue(((var)->name));
-}
-}()))
-);
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-NonnullRefPtr<typename types::CheckedExpression> const& index = __jakt_match_value.index;
-return JaktInternal::ExplicitValue(((((Jakt::DeprecatedString("(("sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(")["sv)) + TRY((((*this).codegen_expression(index))))) + Jakt::DeprecatedString("])"sv)));
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-NonnullRefPtr<typename types::CheckedExpression> const& index = __jakt_match_value.index;
-return JaktInternal::ExplicitValue(((((Jakt::DeprecatedString("(("sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(")["sv)) + TRY((((*this).codegen_expression(index))))) + Jakt::DeprecatedString("])"sv)));
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-size_t const& index = __jakt_match_value.index;
-bool const& is_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (is_optional);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("(({}).map([](auto& _value) {{ return _value.template get<{}>(); }}))"sv),TRY((((*this).codegen_expression(expr)))),index))));
+JaktInternal::Tuple<DeprecatedString,types::EnumId> ___enum_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt_____enum_id__ = ___enum_id__;
+DeprecatedString const _ = ((jakt_____enum_id__).template get<0>());
+types::EnumId const enum_id = ((jakt_____enum_id__).template get<1>());
+
+if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
+continue;
 }
-else {
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("(({}).template get<{}>())"sv),TRY((((*this).codegen_expression(expr)))),index))));
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+if (((seen_types).contains(TRY((((((enum_).type_id)).to_string())))))){
+continue;
 }
-}()))
-);
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-DeprecatedString const& index = __jakt_match_value.index;
-bool const& is_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_559; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-DeprecatedString const object = TRY((((*this).codegen_expression(expr))));
-(output += Jakt::DeprecatedString("(("sv));
-(output += object);
-(output += Jakt::DeprecatedString(")"sv));
-NonnullRefPtr<typename types::Type> const expression_type = ((((*this).program))->get_type(((expr)->type())));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *expression_type;
-switch(__jakt_match_variant.index()) {
-case 25: {
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((enum_).scope_id)))));
 {
-(output += Jakt::DeprecatedString("->"sv));
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-types::CheckedStruct const structure = ((((*this).program))->get_struct(id));
-if ((((((structure).record_type)).index() == 1 /* Class */) && (object != Jakt::DeprecatedString("*this"sv)))){
-(output += Jakt::DeprecatedString("->"sv));
-}
-else {
-(output += Jakt::DeprecatedString("."sv));
-}
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+types::FunctionId function_id = (_magic_value.value());
 {
-types::CheckedStruct const structure = ((((*this).program))->get_struct(id));
-if ((((((structure).record_type)).index() == 1 /* Class */) && (object != Jakt::DeprecatedString("*this"sv)))){
-(output += Jakt::DeprecatedString("->"sv));
+JaktInternal::Optional<DeprecatedString> const value = TRY((((*this).codegen_namespace_specialization(function_id,((enum_).type_id),scope,current_module,define_pass))));
+if (((value).has_value())){
+(output += (value.value()));
 }
-else {
-(output += Jakt::DeprecatedString("."sv));
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-(output += Jakt::DeprecatedString("."sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-if (is_optional){
-(output += Jakt::DeprecatedString("map([](auto& _value) { return _value"sv));
-DeprecatedString access_operator = Jakt::DeprecatedString("."sv);
-if (((expression_type)->index() == 19 /* GenericInstance */)){
-JaktInternal::DynamicArray<types::TypeId> const args = ((expression_type)->get<types::Type::GenericInstance>()).args;
-if ((((args).size()) > static_cast<size_t>(0ULL))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(((args)[static_cast<i64>(0LL)])));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-{
-if (((((((((*this).program))->get_struct(id))).record_type)).index() == 1 /* Class */)){
-(access_operator = Jakt::DeprecatedString("->"sv));
+
 }
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-{
-if (((((((((*this).program))->get_struct(id))).record_type)).index() == 1 /* Class */)){
-(access_operator = Jakt::DeprecatedString("->"sv));
 }
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
 }
+
 }
-(output += access_operator);
-(output += index);
-(output += Jakt::DeprecatedString("; })"sv));
+
 }
-else {
-(output += index);
 }
 
-(output += Jakt::DeprecatedString(")"sv));
-__jakt_var_559 = output; goto __jakt_label_489;
-
-}
-__jakt_label_489:; __jakt_var_559.release_value(); }));
-};/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-DeprecatedString const& index = __jakt_match_value.index;
-bool const& is_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_560; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-DeprecatedString const object = TRY((((*this).codegen_expression(expr))));
-(output += Jakt::DeprecatedString("(("sv));
-(output += object);
-(output += Jakt::DeprecatedString(")"sv));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(((expr)->type())));
-switch(__jakt_match_variant.index()) {
-case 25: {
 {
-(output += Jakt::DeprecatedString("->"sv));
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
+for (;;){
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
+types::ScopeId child_scope_id = (_magic_value.value());
 {
-types::CheckedEnum const structure = ((((*this).program))->get_enum(id));
-if (((((structure).record_type)).index() == 3 /* SumEnum */)){
-bool const is_boxed = ((((structure).record_type)).get<parser::RecordType::SumEnum>()).is_boxed;
-if ((is_boxed && (object != Jakt::DeprecatedString("*this"sv)))){
-(output += Jakt::DeprecatedString("->"sv));
+NonnullRefPtr<types::Scope> const child_scope = TRY((((((*this).program))->get_scope(child_scope_id))));
+if (((((child_scope)->namespace_name)).has_value())){
+DeprecatedString const name = (((child_scope)->namespace_name).value());
+TRY((((((*this).namespace_stack)).push(name))));
+(output += TRY((((*this).codegen_namespace_specializations(child_scope,current_module)))));
+JaktInternal::Optional<DeprecatedString> const dummy = ((((*this).namespace_stack)).pop());
 }
-else {
-(output += Jakt::DeprecatedString("."sv));
 }
 
 }
-else {
-(output += Jakt::DeprecatedString("."sv));
 }
 
+if (((((scope)->namespace_name)).has_value())){
+(output += Jakt::DeprecatedString("}\n"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-{
-types::CheckedEnum const structure = ((((*this).program))->get_enum(id));
-if (((((structure).record_type)).index() == 3 /* SumEnum */)){
-bool const is_boxed = ((((structure).record_type)).get<parser::RecordType::SumEnum>()).is_boxed;
-if ((is_boxed && (object != Jakt::DeprecatedString("*this"sv)))){
-(output += Jakt::DeprecatedString("->"sv));
+return (output);
 }
-else {
-(output += Jakt::DeprecatedString("."sv));
 }
 
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum_type(types::EnumId const id,bool const as_namespace) const {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+NonnullRefPtr<types::Module> const type_module = ((((*this).program))->get_module(((id).module)));
+types::CheckedEnum const checked_enum = ((((*this).program))->get_enum(id));
+if (((!(as_namespace)) && ((checked_enum).is_boxed))){
+(output += Jakt::DeprecatedString("NonnullRefPtr<"sv));
+DeprecatedString const qualifier = TRY((((*this).codegen_namespace_qualifier(((checked_enum).scope_id),true,JaktInternal::OptionalNone()))));
+if ((!(((qualifier).is_empty())))){
+(output += Jakt::DeprecatedString("typename "sv));
+(output += qualifier);
+}
+(output += ((checked_enum).name));
+(output += Jakt::DeprecatedString(">"sv));
 }
 else {
-(output += Jakt::DeprecatedString("."sv));
+DeprecatedString const qualifier = TRY((((*this).codegen_namespace_qualifier(((checked_enum).scope_id),true,JaktInternal::OptionalNone()))));
+if ((!(((qualifier).is_empty())))){
+(output += qualifier);
 }
-
+(output += ((checked_enum).name));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-(output += Jakt::DeprecatedString("."sv));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-if (is_optional){
-(output += Jakt::DeprecatedString("map([](auto& _value) { return _value."sv));
-(output += index);
-(output += Jakt::DeprecatedString("(); })"sv));
-}
-else {
-(output += (index + Jakt::DeprecatedString("()"sv)));
-}
-
-(output += Jakt::DeprecatedString(")"sv));
-__jakt_var_560 = output; goto __jakt_label_490;
-
-}
-__jakt_label_490:; __jakt_var_560.release_value(); }));
-};/*case end*/
-case 18: {
-{
-utility::panic(Jakt::DeprecatedString("Internal error: ComptimeIndex should have been replaced by now"sv));
-}
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_block(block)))));
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_call(call)))));
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedCall const& call = __jakt_match_value.call;
-bool const& is_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_method_call(expr,call,is_optional)))));
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();bool const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (val);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("true"sv));
-}
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("false"sv));
-}
-}()))
-);
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedUnaryOperator const& op = __jakt_match_value.op;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_561; {
-DeprecatedString output = Jakt::DeprecatedString("("sv);
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("++"sv));
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("--"sv));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("-"sv));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(((expr)->type())));
-switch(__jakt_match_variant.index()) {
-case 25: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("*"sv));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue((((Jakt::DeprecatedString("const_cast<"sv) + TRY((((*this).codegen_type(type_id))))) + Jakt::DeprecatedString(">("sv)) + Jakt::DeprecatedString("&"sv)));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("!"sv));
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("~"sv));
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("sizeof"sv));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::Is>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_562; {
-DeprecatedString const is_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_563; {
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
-__jakt_var_563 = (TRY((((*this).codegen_namespace_qualifier(((struct_).scope_id),true,JaktInternal::OptionalNone())))) + ((struct_).name_for_codegen())); goto __jakt_label_493;
-
-}
-__jakt_label_493:; __jakt_var_563.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(type_id)))));
-};/*case end*/
-}/*switch end*/
-}()
-));
-__jakt_var_562 = ((Jakt::DeprecatedString("is<"sv) + is_type) + Jakt::DeprecatedString(">("sv)); goto __jakt_label_492;
-
-}
-__jakt_label_492:; __jakt_var_562.release_value(); }));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::TypeCast>();
-types::CheckedTypeCast const& cast = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_564; {
-types::TypeId final_type_id = ((cast).type_id());
-NonnullRefPtr<typename types::Type> const type = ((((*this).program))->get_type(final_type_id));
-DeprecatedString const cast_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = cast;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_565; {
-types::TypeId const type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *type;
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(((args)[static_cast<i64>(0LL)]));
-};/*case end*/
-default: {
-{
-utility::panic(Jakt::DeprecatedString("Fallible type cast must have Optional result."sv));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-DeprecatedString cast_type = Jakt::DeprecatedString("dynamic_cast"sv);
-if (((((((*this).program))->get_type(type_id)))->index() == 23 /* Struct */)){
-types::StructId const struct_id = ((((((*this).program))->get_type(type_id)))->get<types::Type::Struct>()).value;
-if (((((((((*this).program))->get_struct(struct_id))).record_type)).index() == 1 /* Class */)){
-(final_type_id = type_id);
-(cast_type = Jakt::DeprecatedString("fallible_class_cast"sv));
-}
-else if (((((*this).program))->is_integer(type_id))){
-(final_type_id = type_id);
-(cast_type = Jakt::DeprecatedString("fallible_integer_cast"sv));
-}
-}
-else if (((((*this).program))->is_integer(type_id))){
-(final_type_id = type_id);
-(cast_type = Jakt::DeprecatedString("fallible_integer_cast"sv));
-}
-__jakt_var_565 = cast_type; goto __jakt_label_495;
-
-}
-__jakt_label_495:; __jakt_var_565.release_value(); }));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_566; {
-DeprecatedString cast_type = Jakt::DeprecatedString("verify_cast"sv);
-if (((type)->index() == 23 /* Struct */)){
-types::StructId const struct_id = ((type)->get<types::Type::Struct>()).value;
-if (((((((((*this).program))->get_struct(struct_id))).record_type)).index() == 1 /* Class */)){
-(cast_type = Jakt::DeprecatedString("infallible_class_cast"sv));
-}
-else if (((((*this).program))->is_integer(type_id))){
-(cast_type = Jakt::DeprecatedString("infallible_integer_cast"sv));
-}
-}
-else if (((((*this).program))->is_integer(type_id))){
-(cast_type = Jakt::DeprecatedString("infallible_integer_cast"sv));
-}
-__jakt_var_566 = cast_type; goto __jakt_label_496;
-
-}
-__jakt_label_496:; __jakt_var_566.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-__jakt_var_564 = (((cast_type + Jakt::DeprecatedString("<"sv)) + TRY((((*this).codegen_type(final_type_id))))) + Jakt::DeprecatedString(">("sv)); goto __jakt_label_494;
-
-}
-__jakt_label_494:; __jakt_var_564.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-(output += Jakt::DeprecatedString("("sv));
-DeprecatedString const object = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::Sizeof>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(type_id)))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_expression(expr)))));
-};/*case end*/
-}/*switch end*/
-}()
-));
-(output += object);
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("++)"sv));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("--)"sv));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("))"sv));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("))"sv));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedUnaryOperator::IsEnumVariant>();types::CheckedEnumVariant const& enum_variant = __jakt_match_value.enum_variant;
-types::TypeId const& enum_type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_567; {
-DeprecatedString const name = ((enum_variant).name());
-DeprecatedString suffix = Jakt::DeprecatedString(")"sv);
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(enum_type_id));
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(enum_id);
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue(id);
-};/*case end*/
-default: {
-{
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected type in IsEnumVariant: {}"sv),((((*this).program))->get_type(enum_type_id))))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = ((enum_).record_type);
-switch(__jakt_match_variant.index()) {
-case 3: {
-{
-bool const is_boxed = ((enum_).is_boxed);
-if ((is_boxed && (object != Jakt::DeprecatedString("*this"sv)))){
-(suffix += Jakt::DeprecatedString("->"sv));
-}
-else {
-(suffix += Jakt::DeprecatedString("."sv));
-}
-
-i64 variant_index = static_cast<i64>(0LL);
-{
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedEnumVariant variant = (_magic_value.value());
-{
-if ((((variant).name()) == name)){
-break;
-}
-((variant_index++));
-}
-
-}
-}
-
-(suffix += TRY((__jakt_format(Jakt::DeprecatedString("index() == {} /* {} */"sv),variant_index,name))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-{
-(suffix += TRY((__jakt_format(Jakt::DeprecatedString("== {}::{}"sv),((enum_).name),name))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected enum record type in IsEnumVariant: {}"sv),((enum_).record_type)))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-__jakt_var_567 = suffix; goto __jakt_label_497;
-
-}
-__jakt_label_497:; __jakt_var_567.release_value(); }));
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("))"sv));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(")"sv));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-(output += Jakt::DeprecatedString(")"sv));
-__jakt_var_561 = output; goto __jakt_label_491;
-
-}
-__jakt_label_491:; __jakt_var_561.release_value(); }));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& lhs = __jakt_match_value.lhs;
-NonnullRefPtr<typename types::CheckedExpression> const& rhs = __jakt_match_value.rhs;
-parser::BinaryOperator const& op = __jakt_match_value.op;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_binary_expression(expression,type_id,lhs,rhs,op)))));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NumericConstant>();types::CheckedNumericConstant const& val = __jakt_match_value.val;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_568; {
-DeprecatedString const suffix = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = val;
-switch(__jakt_match_variant.index()) {
-case 3: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("LL"sv));
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("ULL"sv));
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("ULL"sv));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-};/*case end*/
-}/*switch end*/
-}()
-));
-DeprecatedString const type_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = val;
-switch(__jakt_match_variant.index()) {
-case 8: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("size_t"sv));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(type_id)))));
-};/*case end*/
-}/*switch end*/
-}()
-));
-__jakt_var_568 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = val;
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F32>();
-f32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F64>();
-f64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I8>();
-i8 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I16>();
-i16 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I32>();
-i32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I64>();
-i64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U8>();
-u8 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U16>();
-u16 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U32>();
-u32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U64>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::USize>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)); goto __jakt_label_498;
-
-}
-__jakt_label_498:; __jakt_var_568.release_value(); }));
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NamespacedVar>();JaktInternal::DynamicArray<types::CheckedNamespace> const& namespaces = __jakt_match_value.namespaces;
-NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_569; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((((var)->owner_scope)).has_value())){
-(output = TRY((((*this).codegen_namespace_qualifier((((var)->owner_scope).value()),false,JaktInternal::OptionalNone())))));
-}
-else {
-{
-JaktInternal::ArrayIterator<types::CheckedNamespace> _magic = ((namespaces).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedNamespace> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedNamespace ns = (_magic_value.value());
-{
-(output += (((ns).name) + Jakt::DeprecatedString("::"sv)));
-}
-
-}
-}
-
-}
-
-__jakt_var_569 = (output + ((var)->name)); goto __jakt_label_499;
-
-}
-__jakt_label_499:; __jakt_var_569.release_value(); }));
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Match>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-JaktInternal::DynamicArray<types::CheckedMatchCase> const& match_cases = __jakt_match_value.match_cases;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-bool const& all_variants_constant = __jakt_match_value.all_variants_constant;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_match(expr,match_cases,type_id,all_variants_constant)))));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::EnumVariantArg>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedEnumVariantBinding const& arg = __jakt_match_value.arg;
-types::CheckedEnumVariant const& enum_variant = __jakt_match_value.enum_variant;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_570; {
-DeprecatedString const var_name = TRY((((*this).codegen_expression(expr))));
-DeprecatedString const enum_type = TRY((((*this).codegen_type_possibly_as_namespace(((expr)->type()),true))));
-DeprecatedString const variant_name = ((enum_variant).name());
-DeprecatedString arg_name = Jakt::DeprecatedString("value"sv);
-if (((enum_variant).index() == 3 /* StructLike */)){
-(arg_name = ((arg).name).value_or_lazy_evaluated([&] { return ((arg).binding); }));
-}
-DeprecatedString const cpp_deref_operator = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((((((*this).program))->get_enum(((enum_variant).enum_id())))).is_boxed));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("->"sv));
-}
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("."sv));
-}
-}()))
-;
-__jakt_var_570 = TRY((__jakt_format(Jakt::DeprecatedString("(({}){}get<{}::{}>()).{}"sv),var_name,cpp_deref_operator,enum_type,variant_name,arg_name))); goto __jakt_label_500;
-
-}
-__jakt_label_500:; __jakt_var_570.release_value(); }));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& repeat = __jakt_match_value.repeat;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-types::TypeId const& inner_type_id = __jakt_match_value.inner_type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_571; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((repeat).has_value())){
-NonnullRefPtr<typename types::CheckedExpression> const repeat_val = ((repeat).value());
-(output += Jakt::DeprecatedString("("sv));
-(output += TRY((((*this).current_error_handler()))));
-(output += Jakt::DeprecatedString("((DynamicArray<"sv));
-(output += TRY((((*this).codegen_type(inner_type_id)))));
-(output += Jakt::DeprecatedString(">::filled("sv));
-(output += TRY((((*this).codegen_expression(repeat_val)))));
-(output += Jakt::DeprecatedString(", "sv));
-(output += TRY((((*this).codegen_expression(((vals)[static_cast<i64>(0LL)]))))));
-(output += Jakt::DeprecatedString("))))"sv));
-}
-else {
-(output += Jakt::DeprecatedString("("sv));
-(output += TRY((((*this).current_error_handler()))));
-(output += Jakt::DeprecatedString("((DynamicArray<"sv));
-(output += TRY((((*this).codegen_type(inner_type_id)))));
-(output += Jakt::DeprecatedString(">::create_with({"sv));
-bool first = true;
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
-{
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
-}
-else {
-(first = false);
-}
-
-(output += TRY((((*this).codegen_expression(val)))));
-}
-
-}
-}
-
-(output += Jakt::DeprecatedString("}))))"sv));
-}
-
-__jakt_var_571 = output; goto __jakt_label_501;
-
-}
-__jakt_label_501:; __jakt_var_571.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-types::TypeId const& key_type_id = __jakt_match_value.key_type_id;
-types::TypeId const& value_type_id = __jakt_match_value.value_type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_572; {
-DeprecatedString output = TRY((__jakt_format(Jakt::DeprecatedString("({}((Dictionary<{}, {}>::create_with_entries({{"sv),TRY((((*this).current_error_handler()))),TRY((((*this).codegen_type(key_type_id)))),TRY((((*this).codegen_type(value_type_id)))))));
-bool first = true;
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> key__value__ = (_magic_value.value());
-{
-JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> const jakt__key__value__ = key__value__;
-NonnullRefPtr<typename types::CheckedExpression> const key = ((jakt__key__value__).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const value = ((jakt__key__value__).template get<1>());
-
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
-}
-else {
-(first = false);
-}
-
-(output += Jakt::DeprecatedString("{"sv));
-(output += TRY((((*this).codegen_expression(key)))));
-(output += Jakt::DeprecatedString(", "sv));
-(output += TRY((((*this).codegen_expression(value)))));
-(output += Jakt::DeprecatedString("}"sv));
-}
-
-}
-}
-
-(output += Jakt::DeprecatedString("}))))"sv));
-__jakt_var_572 = output; goto __jakt_label_502;
-
-}
-__jakt_label_502:; __jakt_var_572.release_value(); }));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-types::TypeId const& inner_type_id = __jakt_match_value.inner_type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_573; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += TRY((__jakt_format(Jakt::DeprecatedString("({}((Set<{}>::create_with_values({{"sv),TRY((((*this).current_error_handler()))),TRY((((*this).codegen_type(inner_type_id))))))));
-bool first = true;
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-NonnullRefPtr<typename types::CheckedExpression> value = (_magic_value.value());
-{
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
-}
-else {
-(first = false);
-}
-
-(output += TRY((((*this).codegen_expression(value)))));
-}
-
-}
-}
-
-(output += Jakt::DeprecatedString("}))))"sv));
-__jakt_var_573 = output; goto __jakt_label_503;
-
-}
-__jakt_label_503:; __jakt_var_573.release_value(); }));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_574; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += Jakt::DeprecatedString("(Tuple{"sv));
-bool first = true;
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
-{
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
-}
-else {
-(first = false);
-}
-
-(output += TRY((((*this).codegen_expression(val)))));
-}
-
-}
-}
-
-(output += Jakt::DeprecatedString("})"sv));
-__jakt_var_574 = output; goto __jakt_label_504;
-
-}
-__jakt_label_504:; __jakt_var_574.release_value(); }));
-};/*case end*/
-case 30: {
-{
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("Dependent functions should have been resolved by now"sv)))));
-}
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Function>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
-JaktInternal::DynamicArray<types::CheckedParameter> const& params = __jakt_match_value.params;
-bool const& can_throw = __jakt_match_value.can_throw;
-types::CheckedBlock const& block = __jakt_match_value.block;
-types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
-JaktInternal::Optional<types::FunctionId> const& pseudo_function_id = __jakt_match_value.pseudo_function_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_575; {
-JaktInternal::DynamicArray<DeprecatedString> generated_captures = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedCapture capture = (_magic_value.value());
-{
-TRY((((generated_captures).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = capture;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(((capture).name()));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("&"sv));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("&{}"sv),((capture).name())))));
-};/*case end*/
-}/*switch end*/
-}()
-))))));
-}
-
-}
-}
-
-JaktInternal::DynamicArray<DeprecatedString> generated_params = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((params).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedParameter param = (_magic_value.value());
-{
-TRY((((generated_params).push(TRY((__jakt_format(Jakt::DeprecatedString("{} {}"sv),TRY((((*this).codegen_type(((((param).variable))->type_id))))),((((param).variable))->name))))))));
-}
-
-}
-}
-
-DeprecatedString const return_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (can_throw);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),TRY((((*this).codegen_type(return_type_id))))))));
-}
-else {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(return_type_id)))));
-}
-}()))
-;
-DeprecatedString block_output = Jakt::DeprecatedString(""sv);
-if (((pseudo_function_id).has_value())){
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function((pseudo_function_id.value())));
-JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
-(((*this).current_function) = function);
-ScopeGuard __jakt_var_576([&] {
-(((*this).current_function) = previous_function);
-});
-(block_output = TRY((((*this).codegen_lambda_block(can_throw,block,return_type_id)))));
-}
-else {
-(block_output = TRY((((*this).codegen_lambda_block(can_throw,block,return_type_id)))));
-}
-
-__jakt_var_575 = TRY((__jakt_format(Jakt::DeprecatedString("[{}]({}) -> {} {}"sv),utility::join(generated_captures,Jakt::DeprecatedString(", "sv)),utility::join(generated_params,Jakt::DeprecatedString(", "sv)),return_type,block_output))); goto __jakt_label_505;
-
-}
-__jakt_label_505:; __jakt_var_575.release_value(); }));
-};/*case end*/
-case 32: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::TryBlock>();NonnullRefPtr<typename types::CheckedStatement> const& stmt = __jakt_match_value.stmt;
-DeprecatedString const& error_name = __jakt_match_value.error_name;
-types::CheckedBlock const& catch_block = __jakt_match_value.catch_block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_577; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-DeprecatedString const try_var = TRY((((*this).fresh_var())));
-(output += Jakt::DeprecatedString("auto "sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(" = [&]() -> ErrorOr<void> {"sv));
-codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
-(((((*this).control_flow_state)).passes_through_match) = false);
-(((((*this).control_flow_state)).passes_through_try) = true);
-(output += TRY((((*this).codegen_statement(stmt)))));
-(output += Jakt::DeprecatedString(";"sv));
-(output += Jakt::DeprecatedString("return {};"sv));
-(output += Jakt::DeprecatedString("}();\n"sv));
-(output += Jakt::DeprecatedString("if ("sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(".is_error()) {"sv));
-if ((!(((error_name).is_empty())))){
-(output += Jakt::DeprecatedString("auto "sv));
-(output += error_name);
-(output += Jakt::DeprecatedString(" = "sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(".release_error();"sv));
-}
-(output += TRY((((*this).codegen_block(catch_block)))));
-(((*this).control_flow_state) = last_control_flow);
-(output += Jakt::DeprecatedString("}"sv));
-__jakt_var_577 = output; goto __jakt_label_506;
-
-}
-__jakt_label_506:; __jakt_var_577.release_value(); }));
-};/*case end*/
-case 31: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Try>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-JaktInternal::Optional<types::CheckedBlock> const& catch_block = __jakt_match_value.catch_block;
-JaktInternal::Optional<DeprecatedString> const& catch_name = __jakt_match_value.catch_name;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-types::TypeId const& inner_type_id = __jakt_match_value.inner_type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_578; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-DeprecatedString const fresh_var = TRY((((*this).fresh_var())));
-bool const is_void = ((inner_type_id).equals(types::void_type_id()));
-DeprecatedString const try_var = TRY((((*this).fresh_var())));
-codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
-(((((*this).control_flow_state)).passes_through_match) = false);
-(((((*this).control_flow_state)).passes_through_try) = true);
-ScopeGuard __jakt_var_579([&] {
-{
-(((*this).control_flow_state) = last_control_flow);
-}
-
-});
-if ((!(is_void))){
-(output += Jakt::DeprecatedString("({ Optional<"sv));
-(output += TRY((((*this).codegen_type(inner_type_id)))));
-(output += Jakt::DeprecatedString("> "sv));
-(output += fresh_var);
-(output += Jakt::DeprecatedString(";\n"sv));
-}
-(output += Jakt::DeprecatedString("auto "sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(" = [&]() -> ErrorOr<"sv));
-(output += TRY((((*this).codegen_type(inner_type_id)))));
-(output += Jakt::DeprecatedString("> { return "sv));
-(output += TRY((((*this).codegen_expression(expr)))));
-if (is_void){
-(output += Jakt::DeprecatedString(", ErrorOr<void>{}"sv));
-}
-(output += Jakt::DeprecatedString("; }();\n"sv));
-if (((catch_block).has_value())){
-(output += Jakt::DeprecatedString("if ("sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(".is_error()) {"sv));
-if (((catch_name).has_value())){
-(output += Jakt::DeprecatedString("auto "sv));
-(output += (catch_name.value()));
-(output += Jakt::DeprecatedString(" = "sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(".release_error();\n"sv));
-}
-if ((((((catch_block.value())).yielded_type)).has_value())){
-(output += fresh_var);
-(output += Jakt::DeprecatedString(" = ("sv));
-(output += TRY((((*this).codegen_block((catch_block.value()))))));
-(output += Jakt::DeprecatedString(");\n"sv));
-}
-else {
-(output += TRY((((*this).codegen_block((catch_block.value()))))));
-}
-
-if ((!(is_void))){
-(output += Jakt::DeprecatedString("} else {"sv));
-(output += fresh_var);
-(output += Jakt::DeprecatedString(" = "sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(".release_value();\n"sv));
-}
-(output += Jakt::DeprecatedString("}\n"sv));
-}
-else if ((!(is_void))){
-(output += Jakt::DeprecatedString("if (!"sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(".is_error()) "sv));
-(output += fresh_var);
-(output += Jakt::DeprecatedString(" = "sv));
-(output += try_var);
-(output += Jakt::DeprecatedString(".release_value();\n"sv));
-}
-if ((!(is_void))){
-(output += fresh_var);
-if (((catch_block).has_value())){
-(output += Jakt::DeprecatedString(".release_value()"sv));
-}
-(output += Jakt::DeprecatedString("; })"sv));
-}
-__jakt_var_578 = output; goto __jakt_label_507;
-
-}
-__jakt_label_507:; __jakt_var_578.release_value(); }));
-};/*case end*/
-case 34: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedExpression::Garbage>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_580; {
-utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen_expression of bad AST node in {} at {}..{}"sv),TRY((((((*this).compiler))->get_file_path(((span).file_id))))),((span).start),((span).end)))));
-__jakt_var_580 = Jakt::DeprecatedString(""sv); goto __jakt_label_508;
 
-}
-__jakt_label_508:; __jakt_var_580.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+return (output);
 }
 }
 
@@ -3574,276 +2927,202 @@ return (dependencies);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function_in_namespace(NonnullRefPtr<types::CheckedFunction> const function,JaktInternal::Optional<types::TypeId> const containing_struct,bool const as_method,bool const skip_template,JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const explicit_generic_instantiation) {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_checked_binary_op_assignment(NonnullRefPtr<typename types::CheckedExpression> const lhs,NonnullRefPtr<typename types::CheckedExpression> const rhs,parser::BinaryOperator const op,types::TypeId const type_id) {
 {
-if ((!(((((((function)->generics))->params)).is_empty())))){
-if (((((function)->linkage)).index() == 1 /* External */)){
-return (Jakt::DeprecatedString(""sv));
-}
-}
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((!(skip_template))){
-(output += TRY((((*this).codegen_function_generic_parameters(function)))));
-}
-bool const is_main = ((((function)->name_for_codegen()) == Jakt::DeprecatedString("main"sv)) && (!(((containing_struct).has_value()))));
-if (((((function)->return_type_id)).equals(types::never_type_id()))){
-(output += Jakt::DeprecatedString("[[noreturn]] "sv));
-}
-if (is_main){
-(output += Jakt::DeprecatedString("ErrorOr<int>"sv));
-}
-else {
-if ((as_method && ((function)->is_static()))){
-(output += Jakt::DeprecatedString("static "sv));
-}
-if ((!(((((function)->type)).index() == 1 /* Destructor */)))){
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((function)->can_throw));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),TRY((((*this).codegen_type(((function)->return_type_id)))))))));
-}
-else {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(((function)->return_type_id))))));
+(output += Jakt::DeprecatedString("{"sv));
+(output += Jakt::DeprecatedString("auto& _jakt_ref = "sv));
+(output += TRY((((*this).codegen_expression(lhs)))));
+(output += Jakt::DeprecatedString(";"sv));
+(output += Jakt::DeprecatedString("_jakt_ref = JaktInternal::"sv));
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 27: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_add"sv));
+};/*case end*/
+case 28: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_sub"sv));
+};/*case end*/
+case 29: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_mul"sv));
+};/*case end*/
+case 31: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_div"sv));
+};/*case end*/
+case 30: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_mod"sv));
+};/*case end*/
+default: {
+{
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Checked binary operation assignment codegen is not supported for BinaryOperator::{}"sv),op))));
 }
-}()))
-);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+(output += Jakt::DeprecatedString("<"sv));
+(output += TRY((((*this).codegen_type(type_id)))));
+(output += Jakt::DeprecatedString(">(_jakt_ref, "sv));
+(output += TRY((((*this).codegen_expression(rhs)))));
+(output += Jakt::DeprecatedString(");"sv));
+(output += Jakt::DeprecatedString("}"sv));
+return (output);
 }
 }
 
-(output += Jakt::DeprecatedString(" "sv));
-if (is_main){
-(output += Jakt::DeprecatedString("main"sv));
-}
-else {
-DeprecatedString const qualifier = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((containing_struct).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_type_possibly_as_namespace((containing_struct.value()),true)))));
-}
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-}
-}()))
-;
-if ((!(((qualifier).is_empty())))){
-(output += qualifier);
-(output += Jakt::DeprecatedString("::"sv));
-}
-if (((((function)->type)).index() == 1 /* Destructor */)){
-if (((((((*this).program))->get_type((containing_struct.value()))))->index() == 23 /* Struct */)){
-types::StructId const struct_id = ((((((*this).program))->get_type((containing_struct.value()))))->get<types::Type::Struct>()).value;
-(output += (Jakt::DeprecatedString("~"sv) + ((((((*this).program))->get_struct(struct_id))).name_for_codegen())));
-}
-else {
-utility::panic(Jakt::DeprecatedString("Destructor doesn't have a containing struct"sv));
-}
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_expression_and_deref_if_generic_and_needed(NonnullRefPtr<typename types::CheckedExpression> const expression) {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(((expression)->type())));
+switch(__jakt_match_variant.index()) {
+case 18: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_555; {
+DeprecatedString const contents = TRY((((*this).codegen_expression(expression))));
+__jakt_var_555 = TRY((__jakt_format(Jakt::DeprecatedString("(*([]<typename V>(V&& value) {{ if constexpr (IsSpecializationOf<V, NonnullRefPtr>) return &*value; else return &value; }})({}))"sv),contents))); goto __jakt_label_489;
 
 }
-else {
-(output += ((function)->name_for_codegen()));
+__jakt_label_489:; __jakt_var_555.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_expression(expression)))));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
-
 }
 
-if (((explicit_generic_instantiation).has_value())){
-(output += Jakt::DeprecatedString("<"sv));
-bool first = true;
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_struct(types::CheckedStruct const struct_) {
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = (((explicit_generic_instantiation.value())).iterator());
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((((struct_).definition_linkage)).index() == 1 /* External */)){
+return (Jakt::DeprecatedString(""sv));
+}
+bool struct_is_generic = false;
+JaktInternal::DynamicArray<DeprecatedString> generic_parameter_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+if ((!(((((struct_).generic_parameters)).is_empty())))){
+(struct_is_generic = true);
+{
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId type = (_magic_value.value());
+types::CheckedGenericParameter generic_parameter = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
-}
-else {
-(first = false);
-}
-
-(output += TRY((((*this).codegen_type(type)))));
+TRY((((generic_parameter_names).push(TRY((((*this).codegen_type(((generic_parameter).type_id)))))))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(">"sv));
-}
-(output += Jakt::DeprecatedString("("sv));
-if ((is_main && ((((function)->params)).is_empty()))){
-(output += Jakt::DeprecatedString("DynamicArray<DeprecatedString>"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("template <{}>"sv),utility::join(TRY((utility::prepend_to_each(generic_parameter_names,Jakt::DeprecatedString("typename "sv)))),Jakt::DeprecatedString(", "sv))))));
 }
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = ((struct_).record_type);
+switch(__jakt_match_variant.index()) {
+case 1: {
+{
+DeprecatedString class_name_with_generics = Jakt::DeprecatedString(""sv);
+(class_name_with_generics += ((struct_).name_for_codegen()));
 bool first = true;
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+types::CheckedGenericParameter generic_parameter = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedVariable> const variable = ((param).variable);
-if ((((variable)->name) == Jakt::DeprecatedString("this"sv))){
-continue;
-}
 if ((!(first))){
-(output += Jakt::DeprecatedString(","sv));
+(class_name_with_generics += Jakt::DeprecatedString(", "sv));
 }
 else {
+(class_name_with_generics += Jakt::DeprecatedString("<"sv));
 (first = false);
 }
 
-NonnullRefPtr<typename types::Type> const variable_type = ((((*this).program))->get_type(((variable)->type_id)));
-(output += TRY((((*this).codegen_type(((variable)->type_id))))));
-(output += Jakt::DeprecatedString(" "sv));
-if (((!(((variable)->is_mutable))) && (!((((variable_type)->index() == 27 /* Reference */) || ((variable_type)->index() == 28 /* MutableReference */)))))){
-(output += Jakt::DeprecatedString("const "sv));
-}
-(output += ((variable)->name));
-}
-
-}
+(class_name_with_generics += TRY((((*this).codegen_type(((generic_parameter).type_id))))));
 }
 
-(output += Jakt::DeprecatedString(")"sv));
-if (((!(((function)->is_static()))) && (!(((function)->is_mutating()))))){
-(output += Jakt::DeprecatedString(" const"sv));
-}
-(output += Jakt::DeprecatedString(" {\n"sv));
-if (is_main){
-(output += Jakt::DeprecatedString("\n\n            #ifdef _WIN32\n            SetConsoleOutputCP(CP_UTF8);\n            // Enable buffering to prevent VS from chopping up UTF-8 byte sequences\n            setvbuf(stdout, nullptr, _IOFBF, 1000);\n            #endif\n"sv));
-}
-codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
-(((*this).control_flow_state) = ((last_control_flow).enter_function()));
-DeprecatedString const block = TRY((((*this).codegen_block(((function)->block)))));
-(((*this).control_flow_state) = last_control_flow);
-(output += block);
-if (is_main){
-(output += Jakt::DeprecatedString("return 0;\n"sv));
-}
-else {
-if ((((function)->can_throw) && ((((function)->return_type_id)).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } ))))){
-(output += Jakt::DeprecatedString("return {};\n"sv));
 }
 }
 
-(output += Jakt::DeprecatedString("}\n"sv));
-return (output);
-}
+if ((!(((((struct_).generic_parameters)).is_empty())))){
+(class_name_with_generics += Jakt::DeprecatedString(">"sv));
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_destructor_predecl(types::CheckedStruct const& struct_) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += Jakt::DeprecatedString("public:\n"sv));
-(output += ((Jakt::DeprecatedString("    ~"sv) + ((((struct_))).name_for_codegen())) + Jakt::DeprecatedString("();\n"sv)));
-return (output);
+if (((((struct_).super_struct_id)).has_value())){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("class {}: public {} {{\n"sv),((struct_).name_for_codegen()),TRY((((*this).codegen_struct_type((((struct_).super_struct_id).value()),true))))))));
 }
+else {
+(output += TRY((__jakt_format(Jakt::DeprecatedString("class {} : public RefCounted<{}>, public Weakable<{}> {{\n"sv),((struct_).name_for_codegen()),class_name_with_generics,class_name_with_generics))));
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_method_call(NonnullRefPtr<typename types::CheckedExpression> const expr,types::CheckedCall const call,bool const is_optional) {
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((struct_).scope_id)))));
+bool has_destructor = false;
 {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((call).callee_throws)){
-(output += TRY((((*this).current_error_handler()))));
-(output += Jakt::DeprecatedString("(("sv));
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-DeprecatedString const object = TRY((((*this).codegen_expression_and_deref_if_generic_and_needed(expr))));
-(output += Jakt::DeprecatedString("(("sv));
-(output += object);
-(output += Jakt::DeprecatedString(")"sv));
-NonnullRefPtr<typename types::Type> const expression_type = ((((*this).program))->get_type(((expr)->type())));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *expression_type;
-switch(__jakt_match_variant.index()) {
-case 25: {
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___function_ids__ = (_magic_value.value());
 {
-(output += Jakt::DeprecatedString("->"sv));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____function_ids__ = ___function_ids__;
+DeprecatedString const _ = ((jakt_____function_ids__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const function_ids = ((jakt_____function_ids__).template get<1>());
+
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((function_ids).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
+types::FunctionId function_id = (_magic_value.value());
 {
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
-if ((((((struct_).record_type)).index() == 1 /* Class */) && (object != Jakt::DeprecatedString("*this"sv)))){
-(output += Jakt::DeprecatedString("->"sv));
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+if (((((function)->type)).index() == 1 /* Destructor */)){
+(has_destructor = true);
 }
-else {
-(output += Jakt::DeprecatedString("."sv));
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-{
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
-if ((((((struct_).record_type)).index() == 1 /* Class */) && (object != Jakt::DeprecatedString("*this"sv)))){
-(output += Jakt::DeprecatedString("->"sv));
-}
-else {
-(output += Jakt::DeprecatedString("."sv));
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-{
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(id));
-if ((((enum_).is_boxed) && (object != Jakt::DeprecatedString("*this"sv)))){
-(output += Jakt::DeprecatedString("->"sv));
+
 }
-else {
-(output += Jakt::DeprecatedString("."sv));
 }
 
+if ((!(has_destructor))){
+(output += Jakt::DeprecatedString("  public:\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("virtual ~{}() = default;\n"sv),((struct_).name_for_codegen())))));
+}
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 0: {
 {
-(output += Jakt::DeprecatedString("."sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {}"sv),((struct_).name_for_codegen())))));
+(output += Jakt::DeprecatedString(" {\n"sv));
+(output += Jakt::DeprecatedString("  public:\n"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-if (is_optional){
-(output += Jakt::DeprecatedString("map([&](auto& _value) { return _value"sv));
-DeprecatedString access_operator = Jakt::DeprecatedString("."sv);
-if (((expression_type)->index() == 19 /* GenericInstance */)){
-JaktInternal::DynamicArray<types::TypeId> const args = ((expression_type)->get<types::Type::GenericInstance>()).args;
-if ((((args).size()) > static_cast<size_t>(0ULL))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(((args)[static_cast<i64>(0LL)])));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
+case 3: {
 {
-if (((((((((*this).program))->get_struct(id))).record_type)).index() == 1 /* Class */)){
-(access_operator = Jakt::DeprecatedString("->"sv));
-}
+utility::todo(Jakt::DeprecatedString("codegen_struct SumEnum"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+case 2: {
 {
-if (((((((((*this).program))->get_struct(id))).record_type)).index() == 1 /* Class */)){
-(access_operator = Jakt::DeprecatedString("->"sv));
-}
+utility::todo(Jakt::DeprecatedString("codegen_struct ValueEnum"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
@@ -3855,390 +3134,550 @@ return JaktInternal::ExplicitValue<void>();
 }/*switch end*/
 }()
 ));
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedField field = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedVariable> const variable = ((((*this).program))->get_variable(((field).variable_id)));
+(output += TRY((((*this).codegen_type(((variable)->type_id))))));
+(output += Jakt::DeprecatedString(" "sv));
+(output += ((variable)->name));
+(output += Jakt::DeprecatedString(";"sv));
 }
+
 }
-(output += access_operator);
 }
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = ((call).type_args);
-if ((!(((generic_parameters).is_empty())))){
-(output += Jakt::DeprecatedString("template "sv));
+
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((struct_).scope_id)))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-(output += ((call).name_for_codegen()));
-if ((!(((generic_parameters).is_empty())))){
-JaktInternal::DynamicArray<DeprecatedString> types = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((generic_parameters).iterator());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
+
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
 for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId gen_param = (_magic_value.value());
+types::FunctionId function_id = (_magic_value.value());
 {
-TRY((((types).push(TRY((((*this).codegen_type_possibly_as_namespace(gen_param,false))))))));
+JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function_id = ((*this).current_function);
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+(((*this).current_function) = static_cast<JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>>>(function));
+ScopeGuard __jakt_var_556([&] {
+(((*this).current_function) = previous_function_id);
+});
+if (((((function)->type)).index() == 1 /* Destructor */)){
+if (((((struct_).generic_parameters)).is_empty())){
+(output += TRY((((*this).codegen_destructor_predecl(((struct_)))))));
+}
+else {
+(output += TRY((((*this).codegen_destructor(((struct_)),((function)),true)))));
 }
 
+(output += Jakt::DeprecatedString("\n"sv));
+}
+else if (((((function)->type)).index() == 2 /* ImplicitConstructor */)){
+if (((((struct_).generic_parameters)).is_empty())){
+(output += TRY((((*this).codegen_constructor_predecl(function)))));
 }
+else {
+(output += TRY((((*this).codegen_constructor(function,true)))));
 }
 
-(output += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(types,Jakt::DeprecatedString(", "sv))))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
-(output += Jakt::DeprecatedString("("sv));
+else {
+if (struct_is_generic){
+(output += TRY((((*this).codegen_function(function,true)))));
+}
+else if ((((((((function)->generics))->params)).is_empty()) || (!(((((function)->specialization_index)).has_value()))))){
+(output += TRY((((*this).codegen_function_predecl(function,true,false)))));
+}
+}
+
+}
+
+}
+}
+
+}
+
+}
+}
+
+if (((((struct_).generic_parameters)).is_empty())){
+(output += Jakt::DeprecatedString("ErrorOr<DeprecatedString> debug_description() const;\n"sv));
+}
+else {
+(output += TRY((((*this).codegen_debug_description_getter(struct_,true)))));
+}
+
+(output += Jakt::DeprecatedString("};"sv));
+(((*this).deferred_output) += TRY((((*this).codegen_ak_formatter(((struct_).name_for_codegen()),generic_parameter_names)))));
+return (output);
+}
+}
+
+codegen::CodeGenerator::CodeGenerator(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, codegen::ControlFlowState a_control_flow_state, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> a_entered_yieldable_blocks, DeprecatedString a_deferred_output, JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> a_current_function, bool a_inside_defer, codegen::CodegenDebugInfo a_debug_info, JaktInternal::DynamicArray<DeprecatedString> a_namespace_stack, size_t a_fresh_var_counter, size_t a_fresh_label_counter) :compiler(move(a_compiler)), program(move(a_program)), control_flow_state(move(a_control_flow_state)), entered_yieldable_blocks(move(a_entered_yieldable_blocks)), deferred_output(move(a_deferred_output)), current_function(move(a_current_function)), inside_defer(move(a_inside_defer)), debug_info(move(a_debug_info)), namespace_stack(move(a_namespace_stack)), fresh_var_counter(move(a_fresh_var_counter)), fresh_label_counter(move(a_fresh_label_counter)){}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function(NonnullRefPtr<types::CheckedFunction> const function,bool const as_method) {
+{
+if (((function)->is_comptime)){
+return (Jakt::DeprecatedString(""sv));
+}
+return (TRY((((*this).codegen_function_in_namespace(function,JaktInternal::OptionalNone(),as_method,false,JaktInternal::OptionalNone())))));
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_generic_type_instance(types::StructId const id,JaktInternal::DynamicArray<types::TypeId> const args,bool const as_namespace) const {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+NonnullRefPtr<types::Module> const type_module = ((((*this).program))->get_module(((id).module)));
+DeprecatedString namespace_ = Jakt::DeprecatedString(""sv);
+if (((type_module)->is_prelude())){
+(namespace_ += Jakt::DeprecatedString("JaktInternal::"sv));
+}
+JaktInternal::Optional<types::StructId> const inner_weak_ptr_struct_id = TRY((((((*this).program))->check_and_extract_weak_ptr(id,args))));
+if (((inner_weak_ptr_struct_id).has_value())){
+(output += Jakt::DeprecatedString("WeakPtr<"sv));
+(output += namespace_);
+types::StructId const inner_struct_id = ((inner_weak_ptr_struct_id).value());
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(inner_struct_id));
+(output += TRY((((*this).codegen_namespace_qualifier(((struct_).scope_id),true,JaktInternal::OptionalNone())))));
+(output += ((struct_).name_for_codegen()));
+(output += Jakt::DeprecatedString(">"sv));
+}
+else {
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
+bool const acquired_by_ref = ((!(as_namespace)) && ((((struct_).record_type)).index() == 1 /* Class */));
+if (acquired_by_ref){
+(output += Jakt::DeprecatedString("NonnullRefPtr<"sv));
+}
+(output += namespace_);
+(output += TRY((((*this).codegen_namespace_qualifier(((struct_).scope_id),true,JaktInternal::OptionalNone())))));
+(output += ((struct_).name_for_codegen()));
+(output += Jakt::DeprecatedString("<"sv));
 bool first = true;
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> ___expr__ = (_magic_value.value());
+types::TypeId type_id = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const jakt_____expr__ = ___expr__;
-DeprecatedString const _ = ((jakt_____expr__).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const expr = ((jakt_____expr__).template get<1>());
-
-if (first){
-(first = false);
+if ((!(first))){
+(output += Jakt::DeprecatedString(","sv));
 }
 else {
-(output += Jakt::DeprecatedString(","sv));
+(first = false);
 }
 
-(output += TRY((((*this).codegen_expression(expr)))));
+(output += TRY((((*this).codegen_type(type_id)))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(")"sv));
-if (is_optional){
-(output += Jakt::DeprecatedString("; })"sv));
+(output += Jakt::DeprecatedString(">"sv));
+if (acquired_by_ref){
+(output += Jakt::DeprecatedString(">"sv));
 }
-(output += Jakt::DeprecatedString(")"sv));
-if (((call).callee_throws)){
-(output += Jakt::DeprecatedString("))"sv));
 }
+
 return (output);
 }
 }
 
-codegen::CodeGenerator::CodeGenerator(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, codegen::ControlFlowState a_control_flow_state, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> a_entered_yieldable_blocks, DeprecatedString a_deferred_output, JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> a_current_function, bool a_inside_defer, codegen::CodegenDebugInfo a_debug_info, JaktInternal::DynamicArray<DeprecatedString> a_namespace_stack, size_t a_fresh_var_counter, size_t a_fresh_label_counter) :compiler(move(a_compiler)), program(move(a_program)), control_flow_state(move(a_control_flow_state)), entered_yieldable_blocks(move(a_entered_yieldable_blocks)), deferred_output(move(a_deferred_output)), current_function(move(a_current_function)), inside_defer(move(a_inside_defer)), debug_info(move(a_debug_info)), namespace_stack(move(a_namespace_stack)), fresh_var_counter(move(a_fresh_var_counter)), fresh_label_counter(move(a_fresh_label_counter)){}
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_struct(types::CheckedStruct const struct_) {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum_debug_description_getter(types::CheckedEnum const enum_,bool const is_inline) {
 {
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((((struct_).definition_linkage)).index() == 1 /* External */)){
-return (Jakt::DeprecatedString(""sv));
-}
-bool struct_is_generic = false;
-JaktInternal::DynamicArray<DeprecatedString> generic_parameter_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-if ((!(((((struct_).generic_parameters)).is_empty())))){
-(struct_is_generic = true);
-{
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedGenericParameter generic_parameter = (_magic_value.value());
-{
-TRY((((generic_parameter_names).push(TRY((((*this).codegen_type(((generic_parameter).type_id)))))))));
-}
-
-}
-}
-
-(output += TRY((__jakt_format(Jakt::DeprecatedString("template <{}>"sv),utility::join(TRY((utility::prepend_to_each(generic_parameter_names,Jakt::DeprecatedString("typename "sv)))),Jakt::DeprecatedString(", "sv))))));
-}
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = ((struct_).record_type);
-switch(__jakt_match_variant.index()) {
-case 1: {
-{
-DeprecatedString class_name_with_generics = Jakt::DeprecatedString(""sv);
-(class_name_with_generics += ((struct_).name_for_codegen()));
+if (((!(is_inline)) && (!(((((enum_).generic_parameters)).is_empty()))))){
+(output += Jakt::DeprecatedString("template <"sv));
 bool first = true;
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((enum_).generic_parameters)).iterator());
 for (;;){
 JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter generic_parameter = (_magic_value.value());
+types::CheckedGenericParameter param = (_magic_value.value());
 {
-if ((!(first))){
-(class_name_with_generics += Jakt::DeprecatedString(", "sv));
+if (first){
+(first = false);
 }
 else {
-(class_name_with_generics += Jakt::DeprecatedString("<"sv));
-(first = false);
+(output += Jakt::DeprecatedString(","sv));
 }
 
-(class_name_with_generics += TRY((((*this).codegen_type(((generic_parameter).type_id))))));
+(output += Jakt::DeprecatedString("typename "sv));
+(output += TRY((((*this).codegen_type(((param).type_id))))));
 }
 
 }
 }
 
-if ((!(((((struct_).generic_parameters)).is_empty())))){
-(class_name_with_generics += Jakt::DeprecatedString(">"sv));
-}
-if (((((struct_).super_struct_id)).has_value())){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("class {}: public {} {{\n"sv),((struct_).name_for_codegen()),TRY((((*this).codegen_struct_type((((struct_).super_struct_id).value()),true))))))));
+(output += Jakt::DeprecatedString(">\n"sv));
 }
-else {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("class {} : public RefCounted<{}>, public Weakable<{}> {{\n"sv),((struct_).name_for_codegen()),class_name_with_generics,class_name_with_generics))));
+(output += Jakt::DeprecatedString("ErrorOr<DeprecatedString> "sv));
+if ((!(is_inline))){
+(output += TRY((((*this).codegen_type_possibly_as_namespace(((enum_).type_id),true)))));
+(output += Jakt::DeprecatedString("::"sv));
 }
-
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((struct_).scope_id)))));
-bool has_destructor = false;
+(output += Jakt::DeprecatedString("debug_description() const {\n"sv));
+(output += Jakt::DeprecatedString("auto builder = TRY(DeprecatedStringBuilder::create());\n"sv));
+(output += Jakt::DeprecatedString("switch (this->index()) {"sv));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((enum_).variants)).size()))});
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___function_ids__ = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____function_ids__ = ___function_ids__;
-DeprecatedString const _ = ((jakt_____function_ids__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const function_ids = ((jakt_____function_ids__).template get<1>());
-
+types::CheckedEnumVariant const variant = ((((enum_).variants))[i]);
+DeprecatedString const name = ((variant).name());
+(output += TRY((__jakt_format(Jakt::DeprecatedString("case {} /* {} */: {{\n"sv),i,name))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((function_ids).iterator());
+(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.append(\"{}::{}\"sv));\n"sv),((enum_).name),name))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("[[maybe_unused]] auto const& that = this->template get<{}::{}>();\n"sv),((enum_).name),name))));
+(output += Jakt::DeprecatedString("TRY(builder.append(\"(\"sv));\n"sv));
+(output += Jakt::DeprecatedString("{\n"sv));
+(output += Jakt::DeprecatedString("JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};\n"sv));
+size_t i = static_cast<size_t>(0ULL);
+{
+JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId function_id = (_magic_value.value());
+types::VarId field = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-if (((((function)->type)).index() == 1 /* Destructor */)){
-(has_destructor = true);
+(output += Jakt::DeprecatedString("TRY(JaktInternal::PrettyPrint::output_indentation(builder));\n"sv));
+NonnullRefPtr<types::CheckedVariable> const var = ((((*this).program))->get_variable(field));
+if (((((*this).program))->is_string(((var)->type_id)))){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.appendff(\"{}: \\\"{{}}\\\"\", that.{}));\n"sv),((var)->name),((var)->name)))));
 }
+else {
+(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.appendff(\"{}: {{}}\", that.{}));\n"sv),((var)->name),((var)->name)))));
 }
 
+if ((i != (JaktInternal::checked_sub<size_t>(((fields).size()),static_cast<size_t>(1ULL))))){
+(output += Jakt::DeprecatedString("TRY(builder.append(\", \"sv));\n"sv));
 }
-}
-
+((i++));
 }
 
 }
 }
 
-if ((!(has_destructor))){
-(output += Jakt::DeprecatedString("  public:\n"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("virtual ~{}() = default;\n"sv),((struct_).name_for_codegen())))));
-}
+(output += Jakt::DeprecatedString("}\n"sv));
+(output += Jakt::DeprecatedString("TRY(builder.append(\")\"sv));\n"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 0: {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();types::TypeId const& type_id = __jakt_match_value.type_id;
 {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {}"sv),((struct_).name_for_codegen())))));
-(output += Jakt::DeprecatedString(" {\n"sv));
-(output += Jakt::DeprecatedString("  public:\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.append(\"{}::{}\"sv));\n"sv),((enum_).name),name))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("[[maybe_unused]] auto const& that = this->template get<{}::{}>();\n"sv),((enum_).name),name))));
+if (((((*this).program))->is_string(type_id))){
+(output += Jakt::DeprecatedString("TRY(builder.appendff(\"(\\\"{}\\\")\", that.value));\n"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-{
-utility::todo(Jakt::DeprecatedString("codegen_struct SumEnum"sv));
+else {
+(output += Jakt::DeprecatedString("TRY(builder.appendff(\"({})\", that.value));\n"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-{
-utility::todo(Jakt::DeprecatedString("codegen_struct ValueEnum"sv));
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
+(output += TRY((__jakt_format(Jakt::DeprecatedString("return DeprecatedString(\"{}::{}\"sv);\n"sv),((enum_).name),name))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-{
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedField field = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const variable = ((((*this).program))->get_variable(((field).variable_id)));
-(output += TRY((((*this).codegen_type(((variable)->type_id))))));
-(output += Jakt::DeprecatedString(" "sv));
-(output += ((variable)->name));
-(output += Jakt::DeprecatedString(";"sv));
+(output += Jakt::DeprecatedString("break;}\n"sv));
 }
 
 }
 }
 
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((struct_).scope_id)))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(output += Jakt::DeprecatedString("}\nreturn builder.to_string();\n}\n"sv));
+return (output);
+}
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_expression(NonnullRefPtr<typename types::CheckedExpression> const expression) {
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::FunctionId function_id = (_magic_value.value());
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *expression;
+switch(__jakt_match_variant.index()) {
+case 33: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Reflect>();utility::Span const& span = __jakt_match_value.span;
 {
-JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function_id = ((*this).current_function);
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-(((*this).current_function) = static_cast<JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>>>(function));
-ScopeGuard __jakt_var_581([&] {
-(((*this).current_function) = previous_function_id);
-});
-if (((((function)->type)).index() == 1 /* Destructor */)){
-if (((((struct_).generic_parameters)).is_empty())){
-(output += TRY((((*this).codegen_destructor_predecl(((struct_)))))));
-}
-else {
-(output += TRY((((*this).codegen_destructor(((struct_)),((function)),true)))));
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected reflect expression at {}"sv),span))));
 }
-
-(output += Jakt::DeprecatedString("\n"sv));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& from = __jakt_match_value.from;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& to = __jakt_match_value.to;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_557; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+NonnullRefPtr<typename types::Type> const type = ((((*this).program))->get_type(type_id));
+types::TypeId const index_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *type;
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(((args)[static_cast<i64>(0LL)]));
+};/*case end*/
+default: {
+{
+utility::panic(Jakt::DeprecatedString("Internal error: range expression doesn't have Range type"sv));
 }
-else if (((((function)->type)).index() == 2 /* ImplicitConstructor */)){
-if (((((struct_).generic_parameters)).is_empty())){
-(output += TRY((((*this).codegen_constructor_predecl(function)))));
+};/*case end*/
+}/*switch end*/
+}()
+));
+(output += Jakt::DeprecatedString("("sv));
+(output += TRY((((*this).codegen_type(type_id)))));
+(output += Jakt::DeprecatedString("{"sv));
+(output += Jakt::DeprecatedString("static_cast<"sv));
+(output += TRY((((*this).codegen_type(index_type)))));
+(output += Jakt::DeprecatedString(">("sv));
+if (((from).has_value())){
+(output += TRY((((*this).codegen_expression((from.value()))))));
 }
 else {
-(output += TRY((((*this).codegen_constructor(function,true)))));
+(output += Jakt::DeprecatedString("0LL"sv));
 }
 
-(output += Jakt::DeprecatedString("\n"sv));
+(output += Jakt::DeprecatedString("),static_cast<"sv));
+(output += TRY((((*this).codegen_type(index_type)))));
+(output += Jakt::DeprecatedString(">("sv));
+if (((to).has_value())){
+(output += TRY((((*this).codegen_expression((to.value()))))));
 }
 else {
-if (struct_is_generic){
-(output += TRY((((*this).codegen_function(function,true)))));
-}
-else if ((((((((function)->generics))->params)).is_empty()) || (!(((((function)->specialization_index)).has_value()))))){
-(output += TRY((((*this).codegen_function_predecl(function,true,false)))));
-}
-}
-
-}
-
-}
+(output += Jakt::DeprecatedString("9223372036854775807LL"sv));
 }
 
-}
+(output += Jakt::DeprecatedString(")})"sv));
+__jakt_var_557 = output; goto __jakt_label_490;
 
 }
+__jakt_label_490:; __jakt_var_557.release_value(); }));
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("JaktInternal::OptionalNone()"sv));
+};/*case end*/
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalSome>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(((((Jakt::DeprecatedString("static_cast<"sv) + TRY((((*this).codegen_type(type_id))))) + Jakt::DeprecatedString(">("sv)) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(")"sv)));
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(".value())"sv)));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::QuotedString>();types::CheckedStringLiteral const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_558; {
+DeprecatedString const original_string = ((val).to_string());
+DeprecatedString const escaped_value = ((original_string).replace(Jakt::DeprecatedString("\n"sv),Jakt::DeprecatedString("\\n"sv)));
+__jakt_var_558 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((((val).type_id)).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ))));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("Jakt::DeprecatedString(\""sv) + escaped_value) + Jakt::DeprecatedString("\"sv)"sv)));
 }
-
-if (((((struct_).generic_parameters)).is_empty())){
-(output += Jakt::DeprecatedString("ErrorOr<DeprecatedString> debug_description() const;\n"sv));
+else {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_559; {
+DeprecatedString const error_handler = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((val).may_throw));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("TRY"sv));
 }
 else {
-(output += TRY((((*this).codegen_debug_description_getter(struct_,true)))));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
+}()))
+;
+__jakt_var_559 = TRY((__jakt_format(Jakt::DeprecatedString("{}({}::from_string_literal(\"{}\"sv))"sv),error_handler,TRY((((*this).codegen_type(((val).type_id))))),escaped_value))); goto __jakt_label_492;
 
-(output += Jakt::DeprecatedString("};"sv));
-(((*this).deferred_output) += TRY((((*this).codegen_ak_formatter(((struct_).name_for_codegen()),generic_parameter_names)))));
-return (output);
 }
+__jakt_label_492:; __jakt_var_559.release_value(); }));
 }
+}()))
+; goto __jakt_label_491;
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum_predecl(types::CheckedEnum const enum_) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((!(((((enum_).underlying_type_id)).equals(types::void_type_id()))))){
-if (((((*this).program))->is_integer(((enum_).underlying_type_id)))){
-return (TRY((__jakt_format(Jakt::DeprecatedString("enum class {}: {};"sv),((enum_).name),TRY((((*this).codegen_type(((enum_).underlying_type_id)))))))));
+}
+__jakt_label_491:; __jakt_var_558.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ByteConstant>();DeprecatedString const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("'"sv) + val) + Jakt::DeprecatedString("'"sv)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CCharacterConstant>();DeprecatedString const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("'"sv) + val) + Jakt::DeprecatedString("'"sv)));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CharacterConstant>();DeprecatedString const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("static_cast<u32>(U'"sv) + val) + Jakt::DeprecatedString("')"sv)));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((var)->name));
+if (__jakt_enum_value == Jakt::DeprecatedString("this"sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("*this"sv));
 }
 else {
-utility::todo(Jakt::DeprecatedString("Enums with a non-integer underlying type"sv));
+return JaktInternal::ExplicitValue(((var)->name));
 }
-
+}()))
+);
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+NonnullRefPtr<typename types::CheckedExpression> const& index = __jakt_match_value.index;
+return JaktInternal::ExplicitValue(((((Jakt::DeprecatedString("(("sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(")["sv)) + TRY((((*this).codegen_expression(index))))) + Jakt::DeprecatedString("])"sv)));
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+NonnullRefPtr<typename types::CheckedExpression> const& index = __jakt_match_value.index;
+return JaktInternal::ExplicitValue(((((Jakt::DeprecatedString("(("sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(")["sv)) + TRY((((*this).codegen_expression(index))))) + Jakt::DeprecatedString("])"sv)));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+size_t const& index = __jakt_match_value.index;
+bool const& is_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (is_optional);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("(({}).map([](auto& _value) {{ return _value.template get<{}>(); }}))"sv),TRY((((*this).codegen_expression(expr)))),index))));
 }
-bool const is_generic = (!(((((enum_).generic_parameters)).is_empty())));
-JaktInternal::DynamicArray<DeprecatedString> template_args_array = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+else {
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("(({}).template get<{}>())"sv),TRY((((*this).codegen_expression(expr)))),index))));
+}
+}()))
+);
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+DeprecatedString const& index = __jakt_match_value.index;
+bool const& is_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_560; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+DeprecatedString const object = TRY((((*this).codegen_expression(expr))));
+(output += Jakt::DeprecatedString("(("sv));
+(output += object);
+(output += Jakt::DeprecatedString(")"sv));
+NonnullRefPtr<typename types::Type> const expression_type = ((((*this).program))->get_type(((expr)->type())));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *expression_type;
+switch(__jakt_match_variant.index()) {
+case 25: {
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((enum_).generic_parameters)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(output += Jakt::DeprecatedString("->"sv));
 }
-types::CheckedGenericParameter generic_parameter = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
 {
-if (((((((*this).program))->get_type(((generic_parameter).type_id))))->index() == 18 /* TypeVariable */)){
-DeprecatedString const name = ((((((*this).program))->get_type(((generic_parameter).type_id))))->get<types::Type::TypeVariable>()).name;
-TRY((((template_args_array).push((Jakt::DeprecatedString("typename "sv) + name)))));
+types::CheckedStruct const structure = ((((*this).program))->get_struct(id));
+if ((((((structure).record_type)).index() == 1 /* Class */) && (object != Jakt::DeprecatedString("*this"sv)))){
+(output += Jakt::DeprecatedString("->"sv));
 }
+else {
+(output += Jakt::DeprecatedString("."sv));
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+{
+types::CheckedStruct const structure = ((((*this).program))->get_struct(id));
+if ((((((structure).record_type)).index() == 1 /* Class */) && (object != Jakt::DeprecatedString("*this"sv)))){
+(output += Jakt::DeprecatedString("->"sv));
+}
+else {
+(output += Jakt::DeprecatedString("."sv));
 }
 
-DeprecatedString template_args = utility::join(template_args_array,Jakt::DeprecatedString(", "sv));
-(output += (TRY((__jakt_format(Jakt::DeprecatedString("namespace {}_Details"sv),((enum_).name)))) + Jakt::DeprecatedString(" {\n"sv)));
-{
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-if (is_generic){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>\n"sv),template_args))));
-}
-(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {};\n"sv),name))));
+(output += Jakt::DeprecatedString("."sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
+}/*switch end*/
+}()
+));
+if (is_optional){
+(output += Jakt::DeprecatedString("map([](auto& _value) { return _value"sv));
+DeprecatedString access_operator = Jakt::DeprecatedString("."sv);
+if (((expression_type)->index() == 19 /* GenericInstance */)){
+JaktInternal::DynamicArray<types::TypeId> const args = ((expression_type)->get<types::Type::GenericInstance>()).args;
+if ((((args).size()) > static_cast<size_t>(0ULL))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(((args)[static_cast<i64>(0LL)])));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
 {
-if (is_generic){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>\n"sv),template_args))));
+if (((((((((*this).program))->get_struct(id))).record_type)).index() == 1 /* Class */)){
+(access_operator = Jakt::DeprecatedString("->"sv));
 }
-(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {};\n"sv),name))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
 {
-if (is_generic){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>\n"sv),template_args))));
+if (((((((((*this).program))->get_struct(id))).record_type)).index() == 1 /* Class */)){
+(access_operator = Jakt::DeprecatedString("->"sv));
 }
-(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {};\n"sv),name))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
@@ -4251,1514 +3690,1969 @@ return JaktInternal::ExplicitValue<void>();
 }()
 ));
 }
-
-}
-}
-
-(output += Jakt::DeprecatedString("}\n"sv));
-if (is_generic){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>\n"sv),template_args))));
 }
-(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {};\n"sv),((enum_).name)))));
-return (output);
+(output += access_operator);
+(output += index);
+(output += Jakt::DeprecatedString("; })"sv));
 }
+else {
+(output += index);
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_binary_expression(NonnullRefPtr<typename types::CheckedExpression> const expression,types::TypeId const type_id,NonnullRefPtr<typename types::CheckedExpression> const lhs,NonnullRefPtr<typename types::CheckedExpression> const rhs,parser::BinaryOperator const op) {
-{
-if (((op).index() == 20 /* NoneCoalescing */)){
-types::TypeId const rhs_type_id = ((rhs)->type());
-NonnullRefPtr<typename types::Type> const rhs_type = ((((*this).program))->get_type(rhs_type_id));
-bool const rhs_can_throw = ((rhs)->can_throw());
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (rhs_can_throw){
-(output += TRY((((*this).current_error_handler()))));
+(output += Jakt::DeprecatedString(")"sv));
+__jakt_var_560 = output; goto __jakt_label_493;
+
+}
+__jakt_label_493:; __jakt_var_560.release_value(); }));
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+DeprecatedString const& index = __jakt_match_value.index;
+bool const& is_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_561; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+DeprecatedString const object = TRY((((*this).codegen_expression(expr))));
 (output += Jakt::DeprecatedString("(("sv));
+(output += object);
+(output += Jakt::DeprecatedString(")"sv));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(((expr)->type())));
+switch(__jakt_match_variant.index()) {
+case 25: {
+{
+(output += Jakt::DeprecatedString("->"sv));
 }
-(output += TRY((((*this).codegen_expression(lhs)))));
-if (((rhs_type)->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((rhs_type)->get<types::Type::GenericInstance>()).id;
-if ((((((((*this).program))->get_struct(id))).name_for_codegen()) == Jakt::DeprecatedString("Optional"sv))){
-if (rhs_can_throw){
-(output += Jakt::DeprecatedString(".try_value_or_lazy_evaluated_optional"sv));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+{
+types::CheckedEnum const structure = ((((*this).program))->get_enum(id));
+if (((((structure).record_type)).index() == 3 /* SumEnum */)){
+bool const is_boxed = ((((structure).record_type)).get<parser::RecordType::SumEnum>()).is_boxed;
+if ((is_boxed && (object != Jakt::DeprecatedString("*this"sv)))){
+(output += Jakt::DeprecatedString("->"sv));
 }
 else {
-(output += Jakt::DeprecatedString(".value_or_lazy_evaluated_optional"sv));
+(output += Jakt::DeprecatedString("."sv));
 }
 
 }
 else {
-if (rhs_can_throw){
-(output += Jakt::DeprecatedString(".try_value_or_lazy_evaluated"sv));
-}
-else {
-(output += Jakt::DeprecatedString(".value_or_lazy_evaluated"sv));
+(output += Jakt::DeprecatedString("."sv));
 }
 
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+{
+types::CheckedEnum const structure = ((((*this).program))->get_enum(id));
+if (((((structure).record_type)).index() == 3 /* SumEnum */)){
+bool const is_boxed = ((((structure).record_type)).get<parser::RecordType::SumEnum>()).is_boxed;
+if ((is_boxed && (object != Jakt::DeprecatedString("*this"sv)))){
+(output += Jakt::DeprecatedString("->"sv));
 }
 else {
-if (rhs_can_throw){
-(output += Jakt::DeprecatedString(".try_value_or_lazy_evaluated"sv));
+(output += Jakt::DeprecatedString("."sv));
+}
+
 }
 else {
-(output += Jakt::DeprecatedString(".value_or_lazy_evaluated"sv));
+(output += Jakt::DeprecatedString("."sv));
 }
 
 }
-
-if (rhs_can_throw){
-(output += Jakt::DeprecatedString("([&]() -> ErrorOr<"sv));
-(output += TRY((((*this).codegen_type(rhs_type_id)))));
-(output += Jakt::DeprecatedString("> { return "sv));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+(output += Jakt::DeprecatedString("."sv));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+if (is_optional){
+(output += Jakt::DeprecatedString("map([](auto& _value) { return _value."sv));
+(output += index);
+(output += Jakt::DeprecatedString("(); })"sv));
 }
 else {
-(output += Jakt::DeprecatedString("([&] { return "sv));
+(output += (index + Jakt::DeprecatedString("()"sv)));
 }
 
-(output += TRY((((*this).codegen_expression(rhs)))));
-(output += Jakt::DeprecatedString("; })"sv));
-if (rhs_can_throw){
-(output += Jakt::DeprecatedString("))"sv));
-}
-return (output);
+(output += Jakt::DeprecatedString(")"sv));
+__jakt_var_561 = output; goto __jakt_label_494;
+
 }
-if (((op).index() == 32 /* NoneCoalescingAssign */)){
-DeprecatedString output = TRY((((*this).codegen_expression(lhs))));
-(output += Jakt::DeprecatedString(".lazy_emplace([&] { return "sv));
-(output += TRY((((*this).codegen_expression(rhs)))));
-(output += Jakt::DeprecatedString("; })"sv));
-return (output);
+__jakt_label_494:; __jakt_var_561.release_value(); }));
+};/*case end*/
+case 18: {
+{
+utility::panic(Jakt::DeprecatedString("Internal error: ComptimeIndex should have been replaced by now"sv));
 }
-if (((op).index() == 17 /* ArithmeticRightShift */)){
-DeprecatedString output = Jakt::DeprecatedString("JaktInternal::arithmetic_shift_right("sv);
-(output += TRY((((*this).codegen_expression(lhs)))));
-(output += Jakt::DeprecatedString(","sv));
-(output += TRY((((*this).codegen_expression(rhs)))));
-(output += Jakt::DeprecatedString(")"sv));
-return (output);
+};/*case end*/
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_block(block)))));
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_call(call)))));
+};/*case end*/
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedCall const& call = __jakt_match_value.call;
+bool const& is_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_method_call(expr,call,is_optional)))));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();bool const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (val);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("true"sv));
 }
-if ((((op).index() == 21 /* Assign */) && ((lhs)->index() == 14 /* IndexedDictionary */))){
-NonnullRefPtr<typename types::CheckedExpression> const expr = ((lhs)->get<types::CheckedExpression::IndexedDictionary>()).expr;
-NonnullRefPtr<typename types::CheckedExpression> const index = ((lhs)->get<types::CheckedExpression::IndexedDictionary>()).index;
-return (TRY((__jakt_format(Jakt::DeprecatedString("{}({}.set({}, {}))"sv),TRY((((*this).current_error_handler()))),TRY((((*this).codegen_expression(expr)))),TRY((((*this).codegen_expression(index)))),TRY((((*this).codegen_expression(rhs))))))));
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("false"sv));
 }
-if (((((*this).program))->is_integer(type_id))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+}()))
+);
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedUnaryOperator const& op = __jakt_match_value.op;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_562; {
+DeprecatedString output = Jakt::DeprecatedString("("sv);
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
 auto&& __jakt_match_variant = op;
 switch(__jakt_match_variant.index()) {
 case 0: {
-{
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("++"sv));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("--"sv));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("-"sv));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(((expr)->type())));
+switch(__jakt_match_variant.index()) {
+case 25: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("*"sv));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue((((Jakt::DeprecatedString("const_cast<"sv) + TRY((((*this).codegen_type(type_id))))) + Jakt::DeprecatedString(">("sv)) + Jakt::DeprecatedString("&"sv)));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("!"sv));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("~"sv));
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("sizeof"sv));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::Is>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_563; {
+DeprecatedString const is_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_564; {
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
+__jakt_var_564 = (TRY((((*this).codegen_namespace_qualifier(((struct_).scope_id),true,JaktInternal::OptionalNone())))) + ((struct_).name_for_codegen())); goto __jakt_label_497;
+
 }
+__jakt_label_497:; __jakt_var_564.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(type_id)))));
+};/*case end*/
+}/*switch end*/
+}()
+));
+__jakt_var_563 = ((Jakt::DeprecatedString("is<"sv) + is_type) + Jakt::DeprecatedString(">("sv)); goto __jakt_label_496;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_496:; __jakt_var_563.release_value(); }));
 };/*case end*/
-case 1: {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::TypeCast>();
+types::CheckedTypeCast const& cast = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_565; {
+types::TypeId final_type_id = ((cast).type_id());
+NonnullRefPtr<typename types::Type> const type = ((((*this).program))->get_type(final_type_id));
+DeprecatedString const cast_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = cast;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_566; {
+types::TypeId const type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *type;
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(((args)[static_cast<i64>(0LL)]));
+};/*case end*/
+default: {
 {
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+utility::panic(Jakt::DeprecatedString("Fallible type cast must have Optional result."sv));
+}
+};/*case end*/
+}/*switch end*/
+}()
+));
+DeprecatedString cast_type = Jakt::DeprecatedString("dynamic_cast"sv);
+if (((((((*this).program))->get_type(type_id)))->index() == 23 /* Struct */)){
+types::StructId const struct_id = ((((((*this).program))->get_type(type_id)))->get<types::Type::Struct>()).value;
+if (((((((((*this).program))->get_struct(struct_id))).record_type)).index() == 1 /* Class */)){
+(final_type_id = type_id);
+(cast_type = Jakt::DeprecatedString("fallible_class_cast"sv));
+}
+else if (((((*this).program))->is_integer(type_id))){
+(final_type_id = type_id);
+(cast_type = Jakt::DeprecatedString("fallible_integer_cast"sv));
 }
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
+else if (((((*this).program))->is_integer(type_id))){
+(final_type_id = type_id);
+(cast_type = Jakt::DeprecatedString("fallible_integer_cast"sv));
+}
+__jakt_var_566 = cast_type; goto __jakt_label_499;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_499:; __jakt_var_566.release_value(); }));
 };/*case end*/
-case 2: {
-{
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+case 1: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_567; {
+DeprecatedString cast_type = Jakt::DeprecatedString("verify_cast"sv);
+if (((type)->index() == 23 /* Struct */)){
+types::StructId const struct_id = ((type)->get<types::Type::Struct>()).value;
+if (((((((((*this).program))->get_struct(struct_id))).record_type)).index() == 1 /* Class */)){
+(cast_type = Jakt::DeprecatedString("infallible_class_cast"sv));
 }
-
+else if (((((*this).program))->is_integer(type_id))){
+(cast_type = Jakt::DeprecatedString("infallible_integer_cast"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-{
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+else if (((((*this).program))->is_integer(type_id))){
+(cast_type = Jakt::DeprecatedString("infallible_integer_cast"sv));
 }
+__jakt_var_567 = cast_type; goto __jakt_label_500;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_500:; __jakt_var_567.release_value(); }));
 };/*case end*/
-case 4: {
-{
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+__jakt_var_565 = (((cast_type + Jakt::DeprecatedString("<"sv)) + TRY((((*this).codegen_type(final_type_id))))) + Jakt::DeprecatedString(">("sv)); goto __jakt_label_498;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_498:; __jakt_var_565.release_value(); }));
 };/*case end*/
-case 27: {
+default: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+(output += Jakt::DeprecatedString("("sv));
+DeprecatedString const object = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::Sizeof>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(type_id)))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_expression(expr)))));
+};/*case end*/
+}/*switch end*/
+}()
+));
+(output += object);
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 1: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("++)"sv));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("--)"sv));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("))"sv));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("))"sv));
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedUnaryOperator::IsEnumVariant>();types::CheckedEnumVariant const& enum_variant = __jakt_match_value.enum_variant;
+types::TypeId const& enum_type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_568; {
+DeprecatedString const name = ((enum_variant).name());
+DeprecatedString suffix = Jakt::DeprecatedString(")"sv);
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(enum_type_id));
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(enum_id);
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue(id);
+};/*case end*/
+default: {
 {
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
-
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected type in IsEnumVariant: {}"sv),((((*this).program))->get_type(enum_type_id))))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 28: {
+}/*switch end*/
+}()
+))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = ((enum_).record_type);
+switch(__jakt_match_variant.index()) {
+case 3: {
 {
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+bool const is_boxed = ((enum_).is_boxed);
+if ((is_boxed && (object != Jakt::DeprecatedString("*this"sv)))){
+(suffix += Jakt::DeprecatedString("->"sv));
 }
 else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+(suffix += Jakt::DeprecatedString("."sv));
 }
 
+i64 variant_index = static_cast<i64>(0LL);
+{
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 29: {
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+if ((((variant).name()) == name)){
+break;
 }
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+((variant_index++));
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 31: {
-{
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
+(suffix += TRY((__jakt_format(Jakt::DeprecatedString("index() == {} /* {} */"sv),variant_index,name))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 30: {
+case 2: {
 {
-if (((((*this).compiler))->optimize)){
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
-else {
-return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
-}
-
+(suffix += TRY((__jakt_format(Jakt::DeprecatedString("== {}::{}"sv),((enum_).name),name))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected enum record type in IsEnumVariant: {}"sv),((enum_).record_type)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
+__jakt_var_568 = suffix; goto __jakt_label_501;
+
 }
-DeprecatedString output = Jakt::DeprecatedString("("sv);
-(output += TRY((((*this).codegen_expression(lhs)))));
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" + "sv));
+__jakt_label_501:; __jakt_var_568.release_value(); }));
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" - "sv));
+case 6: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("))"sv));
 };/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" * "sv));
+default: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(")"sv));
 };/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" % "sv));
+}/*switch end*/
+}()
+)));
+(output += Jakt::DeprecatedString(")"sv));
+__jakt_var_562 = output; goto __jakt_label_495;
+
+}
+__jakt_label_495:; __jakt_var_562.release_value(); }));
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" / "sv));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& lhs = __jakt_match_value.lhs;
+NonnullRefPtr<typename types::CheckedExpression> const& rhs = __jakt_match_value.rhs;
+parser::BinaryOperator const& op = __jakt_match_value.op;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_binary_expression(expression,type_id,lhs,rhs,op)))));
 };/*case end*/
-case 21: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" = "sv));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NumericConstant>();types::CheckedNumericConstant const& val = __jakt_match_value.val;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_569; {
+DeprecatedString const suffix = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = val;
+switch(__jakt_match_variant.index()) {
+case 3: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("LL"sv));
 };/*case end*/
-case 27: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" += "sv));
+case 7: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("ULL"sv));
 };/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" -= "sv));
+case 8: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("ULL"sv));
 };/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" *= "sv));
+default: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 };/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" %= "sv));
+}/*switch end*/
+}()
+));
+DeprecatedString const type_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = val;
+switch(__jakt_match_variant.index()) {
+case 8: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("size_t"sv));
 };/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" /= "sv));
+default: {
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(type_id)))));
 };/*case end*/
-case 22: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" &= "sv));
+}/*switch end*/
+}()
+));
+__jakt_var_569 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = val;
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F32>();
+f32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
-case 23: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" |= "sv));
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F64>();
+f64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
-case 24: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" ^= "sv));
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I8>();
+i8 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" <<= "sv));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I16>();
+i16 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
-case 26: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" >>= "sv));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I32>();
+i32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" == "sv));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I64>();
+i64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" != "sv));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U8>();
+u8 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" < "sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U16>();
+u16 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
 case 6: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" <= "sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U32>();
+u32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" > "sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U64>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" >= "sv));
-};/*case end*/
-case 18: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" && "sv));
-};/*case end*/
-case 19: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" || "sv));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" & "sv));
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" | "sv));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" ^ "sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::USize>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("static_cast<{}>({}{})"sv),type_name,val,suffix))));
 };/*case end*/
-case 16: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" << "sv));
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_502;
+
+}
+__jakt_label_502:; __jakt_var_569.release_value(); }));
 };/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" << "sv));
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NamespacedVar>();JaktInternal::DynamicArray<types::CheckedNamespace> const& namespaces = __jakt_match_value.namespaces;
+NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_570; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((((var)->owner_scope)).has_value())){
+(output = TRY((((*this).codegen_namespace_qualifier((((var)->owner_scope).value()),false,JaktInternal::OptionalNone())))));
+}
+else {
+{
+JaktInternal::ArrayIterator<types::CheckedNamespace> _magic = ((namespaces).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedNamespace> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedNamespace ns = (_magic_value.value());
+{
+(output += (((ns).name) + Jakt::DeprecatedString("::"sv)));
+}
+
+}
+}
+
+}
+
+__jakt_var_570 = (output + ((var)->name)); goto __jakt_label_503;
+
+}
+__jakt_label_503:; __jakt_var_570.release_value(); }));
 };/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" >> "sv));
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Match>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+JaktInternal::DynamicArray<types::CheckedMatchCase> const& match_cases = __jakt_match_value.match_cases;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+bool const& all_variants_constant = __jakt_match_value.all_variants_constant;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_match(expr,match_cases,type_id,all_variants_constant)))));
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_582; {
-utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen_binary_expression {}"sv),op))));
-__jakt_var_582 = Jakt::DeprecatedString(""sv); goto __jakt_label_509;
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::EnumVariantArg>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedEnumVariantBinding const& arg = __jakt_match_value.arg;
+types::CheckedEnumVariant const& enum_variant = __jakt_match_value.enum_variant;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_571; {
+DeprecatedString const var_name = TRY((((*this).codegen_expression(expr))));
+DeprecatedString const enum_type = TRY((((*this).codegen_type_possibly_as_namespace(((expr)->type()),true))));
+DeprecatedString const variant_name = ((enum_variant).name());
+DeprecatedString arg_name = Jakt::DeprecatedString("value"sv);
+if (((enum_variant).index() == 3 /* StructLike */)){
+(arg_name = ((arg).name).value_or_lazy_evaluated([&] { return ((arg).binding); }));
+}
+DeprecatedString const cpp_deref_operator = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((((((*this).program))->get_enum(((enum_variant).enum_id())))).is_boxed));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("->"sv));
+}
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("."sv));
+}
+}()))
+;
+__jakt_var_571 = TRY((__jakt_format(Jakt::DeprecatedString("(({}){}get<{}::{}>()).{}"sv),var_name,cpp_deref_operator,enum_type,variant_name,arg_name))); goto __jakt_label_504;
 
 }
-__jakt_label_509:; __jakt_var_582.release_value(); }));
+__jakt_label_504:; __jakt_var_571.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-)));
-(output += TRY((((*this).codegen_expression(rhs)))));
-(output += Jakt::DeprecatedString(")"sv));
-return (output);
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& repeat = __jakt_match_value.repeat;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+types::TypeId const& inner_type_id = __jakt_match_value.inner_type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_572; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((repeat).has_value())){
+NonnullRefPtr<typename types::CheckedExpression> const repeat_val = ((repeat).value());
+(output += Jakt::DeprecatedString("("sv));
+(output += TRY((((*this).current_error_handler()))));
+(output += Jakt::DeprecatedString("((DynamicArray<"sv));
+(output += TRY((((*this).codegen_type(inner_type_id)))));
+(output += Jakt::DeprecatedString(">::filled("sv));
+(output += TRY((((*this).codegen_expression(repeat_val)))));
+(output += Jakt::DeprecatedString(", "sv));
+(output += TRY((((*this).codegen_expression(((vals)[static_cast<i64>(0LL)]))))));
+(output += Jakt::DeprecatedString("))))"sv));
 }
+else {
+(output += Jakt::DeprecatedString("("sv));
+(output += TRY((((*this).current_error_handler()))));
+(output += Jakt::DeprecatedString("((DynamicArray<"sv));
+(output += TRY((((*this).codegen_type(inner_type_id)))));
+(output += Jakt::DeprecatedString(">::create_with({"sv));
+bool first = true;
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace_predecl(NonnullRefPtr<types::Scope> const scope,NonnullRefPtr<types::Module> const current_module) {
+NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
 {
-if ((((((scope)->alias_path)).has_value()) || ((((scope)->import_path_if_extern)).has_value()))){
-return (Jakt::DeprecatedString(""sv));
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((((scope)->namespace_name)).has_value())){
-(output += Jakt::DeprecatedString("namespace "sv));
-(output += (((scope)->namespace_name).value()));
-(output += Jakt::DeprecatedString(" {\n"sv));
+else {
+(first = false);
+}
+
+(output += TRY((((*this).codegen_expression(val)))));
+}
+
+}
+}
+
+(output += Jakt::DeprecatedString("}))))"sv));
+}
+
+__jakt_var_572 = output; goto __jakt_label_505;
+
 }
+__jakt_label_505:; __jakt_var_572.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+types::TypeId const& key_type_id = __jakt_match_value.key_type_id;
+types::TypeId const& value_type_id = __jakt_match_value.value_type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_573; {
+DeprecatedString output = TRY((__jakt_format(Jakt::DeprecatedString("({}((Dictionary<{}, {}>::create_with_entries({{"sv),TRY((((*this).current_error_handler()))),TRY((((*this).codegen_type(key_type_id)))),TRY((((*this).codegen_type(value_type_id)))))));
+bool first = true;
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((scope)->structs)).iterator());
+JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::StructId> ___struct_id__ = (_magic_value.value());
+JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> key__value__ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt_____struct_id__ = ___struct_id__;
-DeprecatedString const _ = ((jakt_____struct_id__).template get<0>());
-types::StructId const struct_id = ((jakt_____struct_id__).template get<1>());
+JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> const jakt__key__value__ = key__value__;
+NonnullRefPtr<typename types::CheckedExpression> const key = ((jakt__key__value__).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const value = ((jakt__key__value__).template get<1>());
 
-if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
-continue;
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-(output += TRY((((*this).codegen_struct_predecl(struct_)))));
-(output += Jakt::DeprecatedString("\n"sv));
+else {
+(first = false);
+}
+
+(output += Jakt::DeprecatedString("{"sv));
+(output += TRY((((*this).codegen_expression(key)))));
+(output += Jakt::DeprecatedString(", "sv));
+(output += TRY((((*this).codegen_expression(value)))));
+(output += Jakt::DeprecatedString("}"sv));
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString("}))))"sv));
+__jakt_var_573 = output; goto __jakt_label_506;
+
+}
+__jakt_label_506:; __jakt_var_573.release_value(); }));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+types::TypeId const& inner_type_id = __jakt_match_value.inner_type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_574; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += TRY((__jakt_format(Jakt::DeprecatedString("({}((Set<{}>::create_with_values({{"sv),TRY((((*this).current_error_handler()))),TRY((((*this).codegen_type(inner_type_id))))))));
+bool first = true;
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((scope)->enums)).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::EnumId> ___enum_id__ = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedExpression> value = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt_____enum_id__ = ___enum_id__;
-DeprecatedString const _ = ((jakt_____enum_id__).template get<0>());
-types::EnumId const enum_id = ((jakt_____enum_id__).template get<1>());
-
-if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
-continue;
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-(output += TRY((((*this).codegen_enum_predecl(enum_)))));
-(output += Jakt::DeprecatedString("\n"sv));
+else {
+(first = false);
+}
+
+(output += TRY((((*this).codegen_expression(value)))));
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString("}))))"sv));
+__jakt_var_574 = output; goto __jakt_label_507;
+
+}
+__jakt_label_507:; __jakt_var_574.release_value(); }));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_575; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += Jakt::DeprecatedString("(Tuple{"sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
 for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ScopeId child = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
 {
-(output += TRY((((*this).codegen_namespace_predecl(TRY((((((*this).program))->get_scope(child)))),current_module)))));
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
+}
+else {
+(first = false);
+}
+
+(output += TRY((((*this).codegen_expression(val)))));
 }
 
 }
 }
 
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(output += Jakt::DeprecatedString("})"sv));
+__jakt_var_575 = output; goto __jakt_label_508;
+
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
+__jakt_label_508:; __jakt_var_575.release_value(); }));
+};/*case end*/
+case 30: {
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
-
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("Dependent functions should have been resolved by now"sv)))));
+}
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Function>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
+JaktInternal::DynamicArray<types::CheckedParameter> const& params = __jakt_match_value.params;
+bool const& can_throw = __jakt_match_value.can_throw;
+types::CheckedBlock const& block = __jakt_match_value.block;
+types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
+JaktInternal::Optional<types::FunctionId> const& pseudo_function_id = __jakt_match_value.pseudo_function_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_576; {
+JaktInternal::DynamicArray<DeprecatedString> generated_captures = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId function_id = (_magic_value.value());
+types::CheckedCapture capture = (_magic_value.value());
 {
-if ((!(((((function_id).module)).equals(((current_module)->id)))))){
-continue;
-}
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-if (((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)){
-continue;
-}
-JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function_id = ((*this).current_function);
-(((*this).current_function) = static_cast<JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>>>(function));
-ScopeGuard __jakt_var_583([&] {
-(((*this).current_function) = previous_function_id);
-});
-if (((!(((((function)->type)).index() == 2 /* ImplicitConstructor */))) && ((!(((((function)->type)).index() == 1 /* Destructor */))) && ((((function)->name_for_codegen()) != Jakt::DeprecatedString("main"sv)) && ((((((function)->generics))->params)).is_empty()))))){
-(output += TRY((((*this).codegen_function_predecl(function,false,false)))));
-(output += Jakt::DeprecatedString("\n"sv));
-}
-}
-
-}
-}
-
+TRY((((generated_captures).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = capture;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(((capture).name()));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("&"sv));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("&{}"sv),((capture).name())))));
+};/*case end*/
+}/*switch end*/
+}()
+))))));
 }
 
 }
 }
 
-if (((((scope)->namespace_name)).has_value())){
-(output += Jakt::DeprecatedString("}\n"sv));
-}
-return (output);
-}
+JaktInternal::DynamicArray<DeprecatedString> generated_params = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((params).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::current_error_handler() const {
+types::CheckedParameter param = (_magic_value.value());
 {
-if ((((*this).inside_defer) || ((((((*this).current_function)).has_value()) && (((((((*this).current_function).value()))->return_type_id)).equals(types::never_type_id()))) && (!(((((*this).control_flow_state)).passes_through_try)))))){
-return (Jakt::DeprecatedString("MUST"sv));
+TRY((((generated_params).push(TRY((__jakt_format(Jakt::DeprecatedString("{} {}"sv),TRY((((*this).codegen_type(((((param).variable))->type_id))))),((((param).variable))->name))))))));
 }
-return (Jakt::DeprecatedString("TRY"sv));
+
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace_qualifier(types::ScopeId const scope_id,bool const skip_current,JaktInternal::Optional<DeprecatedString> const possible_constructor_name) const {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-JaktInternal::Optional<types::ScopeId> current_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (skip_current);
+DeprecatedString const return_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (can_throw);
 if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((TRY((((((*this).program))->get_scope(scope_id)))))->parent));
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),TRY((((*this).codegen_type(return_type_id))))))));
 }
 else {
-return JaktInternal::ExplicitValue(scope_id);
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(return_type_id)))));
 }
 }()))
 ;
-bool first = true;
-while (((current_scope_id).has_value())){
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope((current_scope_id.value())))));
-JaktInternal::Optional<DeprecatedString> const name = ((scope)->external_name).value_or_lazy_evaluated_optional([&] { return ((scope)->namespace_name); });
-bool const is_constructor_call = (first && (possible_constructor_name == name));
-ScopeGuard __jakt_var_584([&] {
-{
-if (((name).has_value())){
-(first = false);
-}
-(current_scope_id = ((scope)->parent));
-}
-
+DeprecatedString block_output = Jakt::DeprecatedString(""sv);
+if (((pseudo_function_id).has_value())){
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function((pseudo_function_id.value())));
+JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
+(((*this).current_function) = function);
+ScopeGuard __jakt_var_577([&] {
+(((*this).current_function) = previous_function);
 });
-if (((name).has_value())){
-if (is_constructor_call){
-continue;
-}
-(output = TRY((__jakt_format(Jakt::DeprecatedString("{}::{}"sv),(name.value()),output))));
-}
-}
-return (output);
+(block_output = TRY((((*this).codegen_lambda_block(can_throw,block,return_type_id)))));
 }
+else {
+(block_output = TRY((((*this).codegen_lambda_block(can_throw,block,return_type_id)))));
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_statement(NonnullRefPtr<typename types::CheckedStatement> const statement) {
-{
-bool add_newline = true;
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((((((*this).debug_info)).statement_span_comments) && (((((statement)->span())).has_value()) && add_newline))){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("\n#line {}\n"sv),TRY((((((*this).debug_info)).span_to_source_location((((statement)->span()).value())))))))));
-}
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *statement;
-switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("return "sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(";"sv)));
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((((*this).control_flow_state)).passes_through_match));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("return JaktInternal::LoopContinue{};"sv));
-}
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("continue;"sv));
+__jakt_var_576 = TRY((__jakt_format(Jakt::DeprecatedString("[{}]({}) -> {} {}"sv),utility::join(generated_captures,Jakt::DeprecatedString(", "sv)),utility::join(generated_params,Jakt::DeprecatedString(", "sv)),return_type,block_output))); goto __jakt_label_509;
+
 }
-}()))
-);
+__jakt_label_509:; __jakt_var_576.release_value(); }));
 };/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((((*this).control_flow_state)).passes_through_match));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("return JaktInternal::LoopBreak{};"sv));
+case 32: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::TryBlock>();NonnullRefPtr<typename types::CheckedStatement> const& stmt = __jakt_match_value.stmt;
+DeprecatedString const& error_name = __jakt_match_value.error_name;
+types::CheckedBlock const& catch_block = __jakt_match_value.catch_block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_578; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+DeprecatedString const try_var = TRY((((*this).fresh_var())));
+(output += Jakt::DeprecatedString("auto "sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(" = [&]() -> ErrorOr<void> {"sv));
+codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
+(((((*this).control_flow_state)).passes_through_match) = false);
+(((((*this).control_flow_state)).passes_through_try) = true);
+(output += TRY((((*this).codegen_statement(stmt)))));
+(output += Jakt::DeprecatedString(";"sv));
+(output += Jakt::DeprecatedString("return {};"sv));
+(output += Jakt::DeprecatedString("}();\n"sv));
+(output += Jakt::DeprecatedString("if ("sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(".is_error()) {"sv));
+if ((!(((error_name).is_empty())))){
+(output += Jakt::DeprecatedString("auto "sv));
+(output += error_name);
+(output += Jakt::DeprecatedString(" = "sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(".release_error();"sv));
 }
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("break;"sv));
+(output += TRY((((*this).codegen_block(catch_block)))));
+(((*this).control_flow_state) = last_control_flow);
+(output += Jakt::DeprecatedString("}"sv));
+__jakt_var_578 = output; goto __jakt_label_510;
+
 }
-}()))
-);
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue((TRY((((*this).codegen_expression(expr)))) + Jakt::DeprecatedString(";"sv)));
+__jakt_label_510:; __jakt_var_578.release_value(); }));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.statement;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_585; {
+case 31: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Try>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+JaktInternal::Optional<types::CheckedBlock> const& catch_block = __jakt_match_value.catch_block;
+JaktInternal::Optional<DeprecatedString> const& catch_name = __jakt_match_value.catch_name;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+types::TypeId const& inner_type_id = __jakt_match_value.inner_type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_579; {
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += Jakt::DeprecatedString("ScopeGuard "sv));
-(output += TRY((((*this).fresh_var()))));
-(output += Jakt::DeprecatedString("([&] {\n"sv));
+DeprecatedString const fresh_var = TRY((((*this).fresh_var())));
+bool const is_void = ((inner_type_id).equals(types::void_type_id()));
+DeprecatedString const try_var = TRY((((*this).fresh_var())));
 codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
-bool const old_inside_defer = ((*this).inside_defer);
 (((((*this).control_flow_state)).passes_through_match) = false);
-(((*this).inside_defer) = true);
-(output += TRY((((*this).codegen_statement(statement)))));
-(output += Jakt::DeprecatedString("});"sv));
+(((((*this).control_flow_state)).passes_through_try) = true);
+ScopeGuard __jakt_var_580([&] {
+{
 (((*this).control_flow_state) = last_control_flow);
-(((*this).inside_defer) = old_inside_defer);
-__jakt_var_585 = output; goto __jakt_label_510;
+}
 
+});
+if ((!(is_void))){
+(output += Jakt::DeprecatedString("({ Optional<"sv));
+(output += TRY((((*this).codegen_type(inner_type_id)))));
+(output += Jakt::DeprecatedString("> "sv));
+(output += fresh_var);
+(output += Jakt::DeprecatedString(";\n"sv));
 }
-__jakt_label_510:; __jakt_var_585.release_value(); }));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((val).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((Jakt::DeprecatedString("return ("sv) + TRY((((*this).codegen_expression((val.value())))))) + Jakt::DeprecatedString(");"sv)));
+(output += Jakt::DeprecatedString("auto "sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(" = [&]() -> ErrorOr<"sv));
+(output += TRY((((*this).codegen_type(inner_type_id)))));
+(output += Jakt::DeprecatedString("> { return "sv));
+(output += TRY((((*this).codegen_expression(expr)))));
+if (is_void){
+(output += Jakt::DeprecatedString(", ErrorOr<void>{}"sv));
 }
-else {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_586; {
-__jakt_var_586 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = ((((((*this).current_function).value()))->can_throw));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("return {};"sv));
+(output += Jakt::DeprecatedString("; }();\n"sv));
+if (((catch_block).has_value())){
+(output += Jakt::DeprecatedString("if ("sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(".is_error()) {"sv));
+if (((catch_name).has_value())){
+(output += Jakt::DeprecatedString("auto "sv));
+(output += (catch_name.value()));
+(output += Jakt::DeprecatedString(" = "sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(".release_error();\n"sv));
+}
+if ((((((catch_block.value())).yielded_type)).has_value())){
+(output += fresh_var);
+(output += Jakt::DeprecatedString(" = ("sv));
+(output += TRY((((*this).codegen_block((catch_block.value()))))));
+(output += Jakt::DeprecatedString(");\n"sv));
 }
 else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("return;"sv));
+(output += TRY((((*this).codegen_block((catch_block.value()))))));
 }
-}()))
-; goto __jakt_label_511;
 
+if ((!(is_void))){
+(output += Jakt::DeprecatedString("} else {"sv));
+(output += fresh_var);
+(output += Jakt::DeprecatedString(" = "sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(".release_value();\n"sv));
 }
-__jakt_label_511:; __jakt_var_586.release_value(); }));
-}
-}()))
-);
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_587; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((((((*this).debug_info)).statement_span_comments) && ((((statement)->span())).has_value()))){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("\n#line {}\n"sv),TRY((((((*this).debug_info)).span_to_source_location((((statement)->span()).value())))))))));
+(output += Jakt::DeprecatedString("}\n"sv));
 }
-(output += Jakt::DeprecatedString("for (;;)"sv));
-(add_newline = false);
-codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
-(((*this).control_flow_state) = ((last_control_flow).enter_loop()));
-DeprecatedString const block_str = TRY((((*this).codegen_block(block))));
-(((*this).control_flow_state) = last_control_flow);
-(output += block_str);
-__jakt_var_587 = output; goto __jakt_label_512;
-
+else if ((!(is_void))){
+(output += Jakt::DeprecatedString("if (!"sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(".is_error()) "sv));
+(output += fresh_var);
+(output += Jakt::DeprecatedString(" = "sv));
+(output += try_var);
+(output += Jakt::DeprecatedString(".release_value();\n"sv));
 }
-__jakt_label_512:; __jakt_var_587.release_value(); }));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_588; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((((((*this).debug_info)).statement_span_comments) && ((((statement)->span())).has_value()))){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("\n#line {}\n"sv),TRY((((((*this).debug_info)).span_to_source_location((((statement)->span()).value())))))))));
+if ((!(is_void))){
+(output += fresh_var);
+if (((catch_block).has_value())){
+(output += Jakt::DeprecatedString(".release_value()"sv));
 }
-(output += Jakt::DeprecatedString("while ("sv));
-(output += TRY((((*this).codegen_expression(condition)))));
-(output += Jakt::DeprecatedString(")"sv));
-{
-codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
-(((*this).control_flow_state) = ((last_control_flow).enter_loop()));
-DeprecatedString const code = TRY((((*this).codegen_block(block))));
-(((*this).control_flow_state) = last_control_flow);
-(output += code);
+(output += Jakt::DeprecatedString("; })"sv));
 }
-
-(add_newline = false);
-__jakt_var_588 = output; goto __jakt_label_513;
+__jakt_var_579 = output; goto __jakt_label_511;
 
 }
-__jakt_label_513:; __jakt_var_588.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_block(block)))));
+__jakt_label_511:; __jakt_var_579.release_value(); }));
 };/*case end*/
-case 14: {
-{
-utility::panic(Jakt::DeprecatedString("Garbage statement in codegen"sv));
+case 34: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedExpression::Garbage>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_581; {
+utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen_expression of bad AST node in {} at {}..{}"sv),TRY((((((*this).compiler))->get_file_path(((span).file_id))))),((span).start),((span).end)))));
+__jakt_var_581 = Jakt::DeprecatedString(""sv); goto __jakt_label_512;
+
 }
+__jakt_label_512:; __jakt_var_581.release_value(); }));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& vars = __jakt_match_value.vars;
-NonnullRefPtr<typename types::CheckedStatement> const& var_decl = __jakt_match_value.var_decl;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_589; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += TRY((((*this).codegen_statement(var_decl)))));
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((vars).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-NonnullRefPtr<typename types::CheckedStatement> v = (_magic_value.value());
-{
-(output += TRY((((*this).codegen_statement(v)))));
 }
 
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_binary_expression(NonnullRefPtr<typename types::CheckedExpression> const expression,types::TypeId const type_id,NonnullRefPtr<typename types::CheckedExpression> const lhs,NonnullRefPtr<typename types::CheckedExpression> const rhs,parser::BinaryOperator const op) {
+{
+if (((op).index() == 20 /* NoneCoalescing */)){
+types::TypeId const rhs_type_id = ((rhs)->type());
+NonnullRefPtr<typename types::Type> const rhs_type = ((((*this).program))->get_type(rhs_type_id));
+bool const rhs_can_throw = ((rhs)->can_throw());
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (rhs_can_throw){
+(output += TRY((((*this).current_error_handler()))));
+(output += Jakt::DeprecatedString("(("sv));
 }
+(output += TRY((((*this).codegen_expression(lhs)))));
+if (((rhs_type)->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((rhs_type)->get<types::Type::GenericInstance>()).id;
+if ((((((((*this).program))->get_struct(id))).name_for_codegen()) == Jakt::DeprecatedString("Optional"sv))){
+if (rhs_can_throw){
+(output += Jakt::DeprecatedString(".try_value_or_lazy_evaluated_optional"sv));
 }
-
-__jakt_var_589 = output; goto __jakt_label_514;
-
-}
-__jakt_label_514:; __jakt_var_589.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();types::VarId const& var_id = __jakt_match_value.var_id;
-NonnullRefPtr<typename types::CheckedExpression> const& init = __jakt_match_value.init;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_590; {
-NonnullRefPtr<types::CheckedVariable> const var = ((((*this).program))->get_variable(var_id));
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-NonnullRefPtr<typename types::Type> const var_type = ((((*this).program))->get_type(((var)->type_id)));
-(output += TRY((((*this).codegen_type(((var)->type_id))))));
-(output += Jakt::DeprecatedString(" "sv));
-if (((!(((var)->is_mutable))) && (!((((var_type)->index() == 27 /* Reference */) || ((var_type)->index() == 28 /* MutableReference */)))))){
-(output += Jakt::DeprecatedString("const "sv));
+else {
+(output += Jakt::DeprecatedString(".value_or_lazy_evaluated_optional"sv));
 }
-(output += ((var)->name));
-(output += Jakt::DeprecatedString(" = "sv));
-(output += TRY((((*this).codegen_expression(init)))));
-(output += Jakt::DeprecatedString(";"sv));
-__jakt_var_590 = output; goto __jakt_label_515;
 
 }
-__jakt_label_515:; __jakt_var_590.release_value(); }));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::InlineCpp>();JaktInternal::DynamicArray<DeprecatedString> const& lines = __jakt_match_value.lines;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_591; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-{
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((lines).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else {
+if (rhs_can_throw){
+(output += Jakt::DeprecatedString(".try_value_or_lazy_evaluated"sv));
 }
-DeprecatedString line = (_magic_value.value());
-{
-DeprecatedString escaped_line = line;
-(escaped_line = ((escaped_line).replace(Jakt::DeprecatedString("\\\""sv),Jakt::DeprecatedString("\""sv))));
-(escaped_line = ((escaped_line).replace(Jakt::DeprecatedString("\\\\"sv),Jakt::DeprecatedString("\\"sv))));
-(output += escaped_line);
+else {
+(output += Jakt::DeprecatedString(".value_or_lazy_evaluated"sv));
 }
 
-}
 }
 
-__jakt_var_591 = output; goto __jakt_label_516;
-
-}
-__jakt_label_516:; __jakt_var_591.release_value(); }));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& then_block = __jakt_match_value.then_block;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_592; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((((((*this).debug_info)).statement_span_comments) && ((((statement)->span())).has_value()))){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("\n#line {}\n"sv),TRY((((((*this).debug_info)).span_to_source_location((((statement)->span()).value())))))))));
 }
-(output += Jakt::DeprecatedString("if ("sv));
-(output += TRY((((*this).codegen_expression(condition)))));
-(output += Jakt::DeprecatedString(")"sv));
-(output += TRY((((*this).codegen_block(then_block)))));
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((else_statement).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue((Jakt::DeprecatedString("else "sv) + TRY((((*this).codegen_statement((else_statement.value())))))));
+else {
+if (rhs_can_throw){
+(output += Jakt::DeprecatedString(".try_value_or_lazy_evaluated"sv));
 }
 else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+(output += Jakt::DeprecatedString(".value_or_lazy_evaluated"sv));
 }
-}()))
-);
-(add_newline = false);
-__jakt_var_592 = output; goto __jakt_label_517;
 
 }
-__jakt_label_517:; __jakt_var_592.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_593; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((((((*this).entered_yieldable_blocks)).size()) == static_cast<size_t>(0ULL))){
-utility::panic(Jakt::DeprecatedString("Must be in a block to yield"sv));
-}
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> const var_name_end_label_ = (((((*this).entered_yieldable_blocks)).last()).value());
-DeprecatedString const var_name = ((var_name_end_label_).template get<0>());
-DeprecatedString const end_label = ((var_name_end_label_).template get<1>());
 
-(output += var_name);
-(output += Jakt::DeprecatedString(" = "sv));
-(output += TRY((((*this).codegen_expression(expr)))));
-(output += Jakt::DeprecatedString("; goto "sv));
-(output += end_label);
-(output += Jakt::DeprecatedString(";\n"sv));
-__jakt_var_593 = output; goto __jakt_label_518;
+if (rhs_can_throw){
+(output += Jakt::DeprecatedString("([&]() -> ErrorOr<"sv));
+(output += TRY((((*this).codegen_type(rhs_type_id)))));
+(output += Jakt::DeprecatedString("> { return "sv));
+}
+else {
+(output += Jakt::DeprecatedString("([&] { return "sv));
+}
 
+(output += TRY((((*this).codegen_expression(rhs)))));
+(output += Jakt::DeprecatedString("; })"sv));
+if (rhs_can_throw){
+(output += Jakt::DeprecatedString("))"sv));
 }
-__jakt_label_518:; __jakt_var_593.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-if (add_newline){
-(output += Jakt::DeprecatedString("\n"sv));
+return (output);
+}
+if (((op).index() == 32 /* NoneCoalescingAssign */)){
+DeprecatedString output = TRY((((*this).codegen_expression(lhs))));
+(output += Jakt::DeprecatedString(".lazy_emplace([&] { return "sv));
+(output += TRY((((*this).codegen_expression(rhs)))));
+(output += Jakt::DeprecatedString("; })"sv));
+return (output);
 }
+if (((op).index() == 17 /* ArithmeticRightShift */)){
+DeprecatedString output = Jakt::DeprecatedString("JaktInternal::arithmetic_shift_right("sv);
+(output += TRY((((*this).codegen_expression(lhs)))));
+(output += Jakt::DeprecatedString(","sv));
+(output += TRY((((*this).codegen_expression(rhs)))));
+(output += Jakt::DeprecatedString(")"sv));
 return (output);
 }
+if ((((op).index() == 21 /* Assign */) && ((lhs)->index() == 14 /* IndexedDictionary */))){
+NonnullRefPtr<typename types::CheckedExpression> const expr = ((lhs)->get<types::CheckedExpression::IndexedDictionary>()).expr;
+NonnullRefPtr<typename types::CheckedExpression> const index = ((lhs)->get<types::CheckedExpression::IndexedDictionary>()).index;
+return (TRY((__jakt_format(Jakt::DeprecatedString("{}({}.set({}, {}))"sv),TRY((((*this).current_error_handler()))),TRY((((*this).codegen_expression(expr)))),TRY((((*this).codegen_expression(index)))),TRY((((*this).codegen_expression(rhs))))))));
+}
+if (((((*this).program))->is_integer(type_id))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 0: {
+{
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+}
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
-bool codegen::CodeGenerator::is_full_respecialization(JaktInternal::DynamicArray<types::TypeId> const type_args) const {
-{
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((type_args).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::TypeId type_id = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
 {
-if (((((((*this).program))->get_type(type_id)))->index() == 18 /* TypeVariable */)){
-return (false);
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+{
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
-
-return (true);
-}
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace_path(types::CheckedCall const call) const {
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
 {
-if (((((call).function_id)).has_value())){
-JaktInternal::Optional<types::ScopeId> const scope = ((((((*this).program))->get_function((((call).function_id).value()))))->owner_scope);
-if (((scope).has_value())){
-return (TRY((((*this).codegen_namespace_qualifier((scope.value()),false,((call).name_for_codegen()))))));
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-size_t index = static_cast<size_t>(0ULL);
-{
-JaktInternal::ArrayIterator<types::ResolvedNamespace> _magic = ((((call).namespace_)).iterator());
-for (;;){
-JaktInternal::Optional<types::ResolvedNamespace> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+
 }
-types::ResolvedNamespace namespace_ = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 4: {
 {
-if (((index == (JaktInternal::checked_sub<size_t>(((((call).namespace_)).size()),static_cast<size_t>(1ULL)))) && (((namespace_).name) == ((call).name_for_codegen())))){
-break;
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
-(output += ((namespace_).external_name).value_or_lazy_evaluated([&] { return ((namespace_).name); }));
-if (((((namespace_).generic_parameters)).has_value())){
-(output += Jakt::DeprecatedString("<"sv));
-size_t i = static_cast<size_t>(0ULL);
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = (((((namespace_).generic_parameters).value())).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
-types::TypeId param = (_magic_value.value());
+
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 27: {
 {
-(output += TRY((((*this).codegen_type(param)))));
-if ((i != (JaktInternal::checked_sub<size_t>((((((namespace_).generic_parameters).value())).size()),static_cast<size_t>(1ULL))))){
-(output += Jakt::DeprecatedString(","sv));
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
-(++(i));
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 28: {
+{
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+}
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
-(output += Jakt::DeprecatedString(">"sv));
 }
-(output += Jakt::DeprecatedString("::"sv));
-(++(index));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 29: {
+{
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+}
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 31: {
+{
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+}
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
-return (output);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 30: {
+{
+if (((((*this).compiler))->optimize)){
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_unchecked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
+}
+else {
+return (((Jakt::DeprecatedString("("sv) + TRY((((*this).codegen_checked_binary_op_assignment(lhs,rhs,op,type_id))))) + Jakt::DeprecatedString(")"sv)));
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_type_possibly_as_namespace(types::TypeId const type_id,bool const as_namespace) const {
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+}
+DeprecatedString output = Jakt::DeprecatedString("("sv);
+(output += TRY((((*this).codegen_expression(lhs)))));
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = op;
 switch(__jakt_match_variant.index()) {
 case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("void"sv));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" + "sv));
 };/*case end*/
 case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("bool"sv));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" - "sv));
 };/*case end*/
 case 2: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u8"sv));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" * "sv));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" % "sv));
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u16"sv));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" / "sv));
 };/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u32"sv));
+case 21: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" = "sv));
 };/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u64"sv));
+case 27: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" += "sv));
 };/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i8"sv));
+case 28: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" -= "sv));
 };/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i16"sv));
+case 29: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" *= "sv));
 };/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i32"sv));
+case 30: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" %= "sv));
+};/*case end*/
+case 31: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" /= "sv));
+};/*case end*/
+case 22: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" &= "sv));
+};/*case end*/
+case 23: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" |= "sv));
+};/*case end*/
+case 24: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" ^= "sv));
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" <<= "sv));
+};/*case end*/
+case 26: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" >>= "sv));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i64"sv));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" == "sv));
 };/*case end*/
 case 10: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("f32"sv));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" != "sv));
 };/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("f64"sv));
+case 5: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" < "sv));
 };/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("size_t"sv));
+case 6: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" <= "sv));
 };/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("DeprecatedString"sv));
+case 7: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" > "sv));
 };/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("char"sv));
+case 8: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" >= "sv));
 };/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("int"sv));
+case 18: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" && "sv));
 };/*case end*/
-case 17: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("void"sv));
+case 19: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" || "sv));
 };/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((TRY((((*this).codegen_type(type_id)))) + Jakt::DeprecatedString("*"sv)));
+case 11: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" & "sv));
 };/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((TRY((((*this).codegen_type(type_id)))) + Jakt::DeprecatedString(" const&"sv)));
+case 13: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" | "sv));
 };/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((TRY((((*this).codegen_type(type_id)))) + Jakt::DeprecatedString("&"sv)));
+case 12: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" ^ "sv));
 };/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericResolvedType>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_generic_type_instance(id,args,as_namespace)))));
+case 16: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" << "sv));
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_generic_type_instance(id,args,as_namespace)))));
+case 14: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" << "sv));
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" >> "sv));
 };/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_struct_type(id,as_namespace)))));
+default: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_582; {
+utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen_binary_expression {}"sv),op))));
+__jakt_var_582 = Jakt::DeprecatedString(""sv); goto __jakt_label_513;
+
+}
+__jakt_label_513:; __jakt_var_582.release_value(); }));
 };/*case end*/
+}/*switch end*/
+}()
+)));
+(output += TRY((((*this).codegen_expression(rhs)))));
+(output += Jakt::DeprecatedString(")"sv));
+return (output);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::current_error_handler() const {
+{
+if ((((*this).inside_defer) || ((((((*this).current_function)).has_value()) && (((((((*this).current_function).value()))->return_type_id)).equals(types::never_type_id()))) && (!(((((*this).control_flow_state)).passes_through_try)))))){
+return (Jakt::DeprecatedString("MUST"sv));
+}
+return (Jakt::DeprecatedString("TRY"sv));
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum_match(types::CheckedEnum const enum_,NonnullRefPtr<typename types::CheckedExpression> const expr,JaktInternal::DynamicArray<types::CheckedMatchCase> const match_cases,types::TypeId const type_id,bool const all_variants_constant) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += ((((*this).control_flow_state)).choose_control_flow_macro()));
+DeprecatedString const subject = TRY((((*this).codegen_expression(expr))));
+bool const needs_deref = (((enum_).is_boxed) && (subject != Jakt::DeprecatedString("*this"sv)));
+if (((((enum_).underlying_type_id)).equals(types::void_type_id()))){
+(output += Jakt::DeprecatedString("(([&]() -> JaktInternal::ExplicitValueOrControlFlow<"sv));
+(output += TRY((((*this).codegen_type(type_id)))));
+(output += Jakt::DeprecatedString(", "sv));
+(output += TRY((((*this).codegen_function_return_type((((*this).current_function).value()))))));
+(output += Jakt::DeprecatedString(">{\n"sv));
+(output += Jakt::DeprecatedString("auto&& __jakt_match_variant = "sv));
+if (needs_deref){
+(output += Jakt::DeprecatedString("*"sv));
+}
+(output += (TRY((((*this).codegen_expression(expr)))) + Jakt::DeprecatedString(";\n"sv)));
+(output += Jakt::DeprecatedString("switch(__jakt_match_variant.index()) {\n"sv));
+bool has_default = false;
+{
+JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedMatchCase> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedMatchCase match_case = (_magic_value.value());
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = match_case;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::EnumVariant>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& args = __jakt_match_value.args;
+types::TypeId const& subject_type_id = __jakt_match_value.subject_type_id;
+size_t const& index = __jakt_match_value.index;
+types::ScopeId const& scope_id = __jakt_match_value.scope_id;
+types::CheckedMatchBody const& body = __jakt_match_value.body;
+{
+NonnullRefPtr<typename types::Type> const enum_type = ((((*this).program))->get_type(subject_type_id));
+types::EnumId const enum_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *enum_type;
+switch(__jakt_match_variant.index()) {
 case 24: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
 types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_enum_type(id,as_namespace)))));
+return JaktInternal::ExplicitValue(id);
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(TRY((((*this).codegen_generic_enum_instance(id,args,as_namespace)))));
+default: {
+{
+utility::panic(Jakt::DeprecatedString("Expected enum type"sv));
+}
 };/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::TypeVariable>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(name);
+}/*switch end*/
+}()
+));
+types::CheckedEnum const match_case_enum = ((((*this).program))->get_enum(enum_id));
+types::CheckedEnumVariant const variant = ((((match_case_enum).variants))[index]);
+(output += (TRY((__jakt_format(Jakt::DeprecatedString("case {}: "sv),index))) + Jakt::DeprecatedString("{\n"sv)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
+{
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
-bool const& can_throw = __jakt_match_value.can_throw;
-types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_594; {
-DeprecatedString output = Jakt::DeprecatedString("Function<"sv);
-if (can_throw){
-(output += Jakt::DeprecatedString("ErrorOr<"sv));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+{
+if ((!(((args).is_empty())))){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("auto&& __jakt_match_value = __jakt_match_variant.template get<typename {}::{}>();\n"sv),TRY((((*this).codegen_type_possibly_as_namespace(subject_type_id,true)))),name))));
+parser::EnumVariantPatternArgument const arg = ((args)[static_cast<i64>(0LL)]);
+NonnullRefPtr<types::CheckedVariable> const var = (TRY((((((*this).program))->find_var_in_scope(scope_id,((arg).binding))))).value());
+(output += TRY((((*this).codegen_type(((var)->type_id))))));
+if ((!(((var)->is_mutable)))){
+(output += Jakt::DeprecatedString(" const"sv));
 }
-(output += TRY((((*this).codegen_type(return_type_id)))));
-if (can_throw){
-(output += Jakt::DeprecatedString(">"sv));
+(output += Jakt::DeprecatedString("& "sv));
+(output += ((arg).binding));
+(output += Jakt::DeprecatedString(" = __jakt_match_value.value;\n"sv));
 }
-(output += Jakt::DeprecatedString("("sv));
-bool first = true;
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((params).iterator());
+if ((!(((args).is_empty())))){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("auto&& __jakt_match_value = __jakt_match_variant.template get<{}::{}>();"sv),TRY((((*this).codegen_type_possibly_as_namespace(subject_type_id,true)))),name))));
+{
+JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = ((args).iterator());
 for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId param = (_magic_value.value());
+parser::EnumVariantPatternArgument arg = (_magic_value.value());
 {
-if (first){
-(first = false);
-}
-else {
-(output += Jakt::DeprecatedString(", "sv));
+NonnullRefPtr<types::CheckedVariable> const var = (TRY((((((*this).program))->find_var_in_scope(scope_id,((arg).binding))))).value());
+(output += TRY((((*this).codegen_type(((var)->type_id))))));
+if ((!(((var)->is_mutable)))){
+(output += Jakt::DeprecatedString(" const"sv));
 }
-
-(output += TRY((((*this).codegen_type(param)))));
+(output += Jakt::DeprecatedString("& "sv));
+(output += ((arg).binding));
+(output += Jakt::DeprecatedString(" = __jakt_match_value."sv));
+(output += ((((arg).name)).value_or(((arg).binding))));
+(output += Jakt::DeprecatedString(";\n"sv));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(")>"sv));
-__jakt_var_594 = output; goto __jakt_label_519;
-
 }
-__jakt_label_519:; __jakt_var_594.release_value(); }));
-};/*case end*/
-case 21: {
-{
-utility::panic(Jakt::DeprecatedString("Generic trait instance in codegen"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_595; {
-__jakt_var_595 = Jakt::DeprecatedString("auto"sv); goto __jakt_label_520;
-
+{
+utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen_enum_match match variant else: {}"sv),variant))));
 }
-__jakt_label_520:; __jakt_var_595.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
+));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((match_case).defaults())).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+NonnullRefPtr<typename types::CheckedStatement> default_ = (_magic_value.value());
+{
+(output += TRY((((*this).codegen_statement(default_)))));
 }
 
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> codegen::CodeGenerator::extract_dependencies_from(types::TypeId const type_id,JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph,bool const top_level) const {
+}
+}
+
+(output += TRY((((*this).codegen_match_body(body,type_id)))));
+(output += Jakt::DeprecatedString("};/*case end*/\n"sv));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
 {
-JaktInternal::DynamicArray<DeprecatedString> dependencies = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-if (((dependency_graph).contains(TRY((((type_id).to_string())))))){
+(has_default = true);
+(output += Jakt::DeprecatedString("default: {\n"sv));
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = (((((dependency_graph).get(TRY((((type_id).to_string()))))).value())).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((match_case).defaults())).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString dependency = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedStatement> default_ = (_magic_value.value());
 {
-TRY((((dependencies).push(dependency))));
+(output += TRY((((*this).codegen_statement(default_)))));
 }
 
 }
 }
 
-return (dependencies);
+(output += TRY((((*this).codegen_match_body(body,type_id)))));
+(output += Jakt::DeprecatedString("};/*case end*/\n"sv));
 }
-NonnullRefPtr<typename types::Type> const type_ = ((((*this).program))->get_type(type_id));
-JaktInternal::DynamicArray<DeprecatedString> const inner_dependencies = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<DeprecatedString>, ErrorOr<JaktInternal::DynamicArray<DeprecatedString>>>{
-auto&& __jakt_match_variant = *type_;
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).extract_dependencies_from_enum(enum_id,dependency_graph,top_level)))));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue(TRY((((*this).extract_dependencies_from_enum(id,dependency_graph,top_level)))));
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).extract_dependencies_from_struct(id,dependency_graph,top_level,(TRY((DynamicArray<types::TypeId>::create_with({})))))))));
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(TRY((((*this).extract_dependencies_from_struct(id,dependency_graph,top_level,args)))));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue((TRY((DynamicArray<DeprecatedString>::create_with({})))));
+{
+utility::panic(Jakt::DeprecatedString("Matching enum subject with non-enum value"sv));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
+}
+
+}
+}
+
+if ((!(has_default))){
+if ((((((enum_).variants)).size()) != ((match_cases).size()))){
+utility::panic(Jakt::DeprecatedString("Inexhaustive match statement"sv));
+}
+(output += Jakt::DeprecatedString("default: VERIFY_NOT_REACHED();"sv));
+}
+(output += Jakt::DeprecatedString("}/*switch end*/\n"sv));
+(output += Jakt::DeprecatedString("}()\n))"sv));
+}
+else {
+(output += Jakt::DeprecatedString("(([&]() -> JaktInternal::ExplicitValueOrControlFlow<"sv));
+(output += TRY((((*this).codegen_type(type_id)))));
+(output += Jakt::DeprecatedString(", "sv));
+(output += TRY((((*this).codegen_function_return_type((((*this).current_function).value()))))));
+(output += Jakt::DeprecatedString(">{\n"sv));
+(output += ((Jakt::DeprecatedString("switch ("sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(") {\n"sv)));
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((inner_dependencies).iterator());
+JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedMatchCase> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString dependency = (_magic_value.value());
-{
-TRY((((dependencies).push(dependency))));
-}
-
-}
-}
-
-return (dependencies);
-}
-}
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_match_body(types::CheckedMatchBody const body,types::TypeId const return_type_id) {
+types::CheckedMatchCase match_case = (_magic_value.value());
 {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = body;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = match_case;
 switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Block>();
-types::CheckedBlock const& block = __jakt_match_value.value;
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::EnumVariant>();DeprecatedString const& name = __jakt_match_value.name;
+types::CheckedMatchBody const& body = __jakt_match_value.body;
 {
-(output += TRY((((*this).codegen_block(block)))));
-if ((((return_type_id).equals(types::void_type_id())) || ((return_type_id).equals(types::unknown_type_id())))){
-(output += Jakt::DeprecatedString("return JaktInternal::ExplicitValue<void>();\n"sv));
-}
+(output += ((((Jakt::DeprecatedString("case "sv) + ((enum_).name)) + Jakt::DeprecatedString("::"sv)) + name) + Jakt::DeprecatedString(": {\n"sv)));
+(output += TRY((((*this).codegen_match_body(body,type_id)))));
+(output += Jakt::DeprecatedString("}\n"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Expression>();
-NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.value;
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
 {
-if ((((((expr)->type())).equals(types::void_type_id())) || (((((expr)->type())).equals(types::unknown_type_id())) && (!(((expr)->index() == 25 /* OptionalNone */)))))){
-(output += Jakt::DeprecatedString("return ("sv));
-(output += TRY((((*this).codegen_expression(expr)))));
-(output += Jakt::DeprecatedString("), JaktInternal::ExplicitValue<void>();\n"sv));
-}
-else {
-(output += Jakt::DeprecatedString("return JaktInternal::ExplicitValue("sv));
-(output += TRY((((*this).codegen_expression(expr)))));
-(output += Jakt::DeprecatedString(");\n"sv));
+(output += Jakt::DeprecatedString("default: {\n"sv));
+(output += TRY((((*this).codegen_match_body(body,type_id)))));
+(output += Jakt::DeprecatedString("}\n"sv));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("underlying type enum match, match_case: {}"sv),match_case))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 ));
+}
+
+}
+}
+
+(output += Jakt::DeprecatedString("}/*switch end*/\n"sv));
+(output += Jakt::DeprecatedString("}()\n))"sv));
+}
+
 return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function_predecl(NonnullRefPtr<types::CheckedFunction> const function,bool const as_method,bool const allow_generics) {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace_path(types::CheckedCall const call) const {
 {
+if (((((call).function_id)).has_value())){
+JaktInternal::Optional<types::ScopeId> const scope = ((((((*this).program))->get_function((((call).function_id).value()))))->owner_scope);
+if (((scope).has_value())){
+return (TRY((((*this).codegen_namespace_qualifier((scope.value()),false,((call).name_for_codegen()))))));
+}
+}
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((allow_generics || (!(((((((function)->generics))->params)).is_empty())))) && ((((function)->linkage)).index() == 1 /* External */))){
-return (Jakt::DeprecatedString(""sv));
+size_t index = static_cast<size_t>(0ULL);
+{
+JaktInternal::ArrayIterator<types::ResolvedNamespace> _magic = ((((call).namespace_)).iterator());
+for (;;){
+JaktInternal::Optional<types::ResolvedNamespace> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-if (((function)->is_comptime)){
-return (Jakt::DeprecatedString(""sv));
+types::ResolvedNamespace namespace_ = (_magic_value.value());
+{
+if (((index == (JaktInternal::checked_sub<size_t>(((((call).namespace_)).size()),static_cast<size_t>(1ULL)))) && (((namespace_).name) == ((call).name_for_codegen())))){
+break;
 }
-if (((((function)->type)).index() == 2 /* ImplicitConstructor */)){
-return (Jakt::DeprecatedString(""sv));
+(output += ((namespace_).external_name).value_or_lazy_evaluated([&] { return ((namespace_).name); }));
+if (((((namespace_).generic_parameters)).has_value())){
+(output += Jakt::DeprecatedString("<"sv));
+size_t i = static_cast<size_t>(0ULL);
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = (((((namespace_).generic_parameters).value())).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-if (((((function)->linkage)).index() == 1 /* External */)){
-(output += Jakt::DeprecatedString("extern "sv));
+types::TypeId param = (_magic_value.value());
+{
+(output += TRY((((*this).codegen_type(param)))));
+if ((i != (JaktInternal::checked_sub<size_t>((((((namespace_).generic_parameters).value())).size()),static_cast<size_t>(1ULL))))){
+(output += Jakt::DeprecatedString(","sv));
 }
-(output += TRY((((*this).codegen_function_generic_parameters(function)))));
-if (((((function)->return_type_id)).equals(types::never_type_id()))){
-(output += Jakt::DeprecatedString("[[noreturn]] "sv));
+(++(i));
 }
-if ((((function)->name_for_codegen()) == Jakt::DeprecatedString("main"sv))){
-(output += Jakt::DeprecatedString("ErrorOr<int>"sv));
+
 }
-else {
-if ((as_method && ((function)->is_static()))){
-(output += Jakt::DeprecatedString("static "sv));
 }
-if (((function)->is_virtual)){
-(output += Jakt::DeprecatedString("virtual "sv));
+
+(output += Jakt::DeprecatedString(">"sv));
 }
-DeprecatedString const naked_return_type = TRY((((*this).codegen_type(((function)->return_type_id)))));
-DeprecatedString const return_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((function)->can_throw));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),naked_return_type))));
+(output += Jakt::DeprecatedString("::"sv));
+(++(index));
 }
-else {
-return JaktInternal::ExplicitValue(naked_return_type);
+
 }
-}()))
-;
-(output += return_type);
 }
 
-(output += Jakt::DeprecatedString(" "sv));
-(output += ((function)->name_for_codegen()));
-(output += Jakt::DeprecatedString("("sv));
-bool first = true;
+return (output);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum(types::CheckedEnum const enum_) {
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((!(((((enum_).underlying_type_id)).equals(types::void_type_id()))))){
+if (((((*this).program))->is_integer(((enum_).underlying_type_id)))){
+(output += ((((Jakt::DeprecatedString("enum class "sv) + ((enum_).name)) + Jakt::DeprecatedString(": "sv)) + TRY((((*this).codegen_type(((enum_).underlying_type_id)))))) + Jakt::DeprecatedString(" {\n"sv)));
+{
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-if ((first && (((((param).variable))->name) == Jakt::DeprecatedString("this"sv)))){
-continue;
-}
-if (first){
-(first = false);
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& name = __jakt_match_value.name;
+NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue((((name + Jakt::DeprecatedString(" = "sv)) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(",\n"sv)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_583; {
+utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen_enum can't generate variant: {}"sv),variant))));
+__jakt_var_583 = Jakt::DeprecatedString(""sv); goto __jakt_label_514;
+
 }
-else {
-(output += Jakt::DeprecatedString(", "sv));
+__jakt_label_514:; __jakt_var_583.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 
-NonnullRefPtr<typename types::Type> const param_type = ((((*this).program))->get_type(((((param).variable))->type_id)));
-(output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
-(output += Jakt::DeprecatedString(" "sv));
-if (((!(((((param).variable))->is_mutable))) && (!((((param_type)->index() == 27 /* Reference */) || ((param_type)->index() == 28 /* MutableReference */)))))){
-(output += Jakt::DeprecatedString("const "sv));
 }
-(output += ((((param).variable))->name));
 }
 
+return ((output + Jakt::DeprecatedString("};\n"sv)));
 }
+else {
+utility::todo(Jakt::DeprecatedString("Enums with a non-integer underlying type"sv));
 }
 
-(output += Jakt::DeprecatedString(")"sv));
-if (((!(((function)->is_static()))) && (!(((function)->is_mutating()))))){
-(output += Jakt::DeprecatedString(" const"sv));
 }
-if (((function)->is_override)){
-(output += Jakt::DeprecatedString(" override"sv));
+bool const is_generic = (!(((((enum_).generic_parameters)).is_empty())));
+JaktInternal::DynamicArray<DeprecatedString> generic_parameter_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((enum_).generic_parameters)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-(output += Jakt::DeprecatedString(";"sv));
-(output += Jakt::DeprecatedString("\n"sv));
-return (output);
+types::CheckedGenericParameter generic_parameter = (_magic_value.value());
+{
+if (((((((*this).program))->get_type(((generic_parameter).type_id))))->index() == 18 /* TypeVariable */)){
+DeprecatedString const name = ((((((*this).program))->get_type(((generic_parameter).type_id))))->get<types::Type::TypeVariable>()).name;
+TRY((((generic_parameter_names).push(name))));
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::fresh_var() {
-{
-return (TRY((__jakt_format(Jakt::DeprecatedString("__jakt_var_{}"sv),((((*this).fresh_var_counter)++))))));
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_destructor(types::CheckedStruct const& struct_,NonnullRefPtr<types::CheckedFunction> const& function,bool const is_inline) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-DeprecatedString const qualified_name = TRY((((*this).codegen_type_possibly_as_namespace(((((struct_))).type_id),true))));
-if (((!(is_inline)) && (!(((((((struct_))).generic_parameters)).is_empty()))))){
-(output += Jakt::DeprecatedString("template <"sv));
-bool first = true;
+DeprecatedString template_args = utility::join(TRY((utility::prepend_to_each(generic_parameter_names,Jakt::DeprecatedString("typename "sv)))),Jakt::DeprecatedString(", "sv));
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> common_fields = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((((struct_))).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter param = (_magic_value.value());
+types::CheckedField field = (_magic_value.value());
 {
-if (first){
-(first = false);
-}
-else {
-(output += Jakt::DeprecatedString(","sv));
+NonnullRefPtr<types::CheckedVariable> const variable = ((((*this).program))->get_variable(((field).variable_id)));
+TRY((((common_fields).push((Tuple{((variable)->name), TRY((((*this).codegen_type(((variable)->type_id)))))})))));
 }
 
-(output += Jakt::DeprecatedString("typename "sv));
-(output += TRY((((*this).codegen_type(((param).type_id))))));
+}
 }
 
+(output += ((Jakt::DeprecatedString("namespace "sv) + ((enum_).name)) + Jakt::DeprecatedString("_Details {\n"sv)));
+{
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+types::CheckedEnumVariant variant = (_magic_value.value());
+{
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const fields = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> __jakt_var_584; {
+if (is_generic){
+(output += ((Jakt::DeprecatedString("template<"sv) + template_args) + Jakt::DeprecatedString(">\n"sv)));
 }
+(output += ((Jakt::DeprecatedString("struct "sv) + name) + Jakt::DeprecatedString(" {\n"sv)));
+__jakt_var_584 = common_fields; goto __jakt_label_515;
 
-(output += Jakt::DeprecatedString(">\n"sv));
 }
-if (is_inline){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("~{}()"sv),((((struct_))).name_for_codegen())))));
+__jakt_label_515:; __jakt_var_584.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<types::VarId> const& own_fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> __jakt_var_585; {
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> fields = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::VarId> _magic = ((own_fields).iterator());
+for (;;){
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("{}::~{}()"sv),qualified_name,((((struct_))).name_for_codegen())))));
+types::VarId field = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedVariable> const variable = ((((*this).program))->get_variable(field));
+TRY((((fields).push((Tuple{((variable)->name), TRY((((*this).codegen_type(((variable)->type_id)))))})))));
 }
 
-(output += TRY((((*this).codegen_block(((((function)))->block))))));
-return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_block(types::CheckedBlock const block) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((((block).yielded_type)).has_value())){
-types::TypeId const yielded_type = (((block).yielded_type).value());
-DeprecatedString const type_output = TRY((((*this).codegen_type(yielded_type))));
-DeprecatedString const fresh_var = TRY((((*this).fresh_var())));
-DeprecatedString const fresh_label = TRY((((*this).fresh_label())));
-TRY((((((*this).entered_yieldable_blocks)).push((Tuple{fresh_var, fresh_label})))));
-(output += Jakt::DeprecatedString("({ Optional<"sv));
-(output += type_output);
-(output += Jakt::DeprecatedString("> "sv));
-(output += fresh_var);
-(output += Jakt::DeprecatedString("; "sv));
+if (is_generic){
+(output += ((Jakt::DeprecatedString("template<"sv) + template_args) + Jakt::DeprecatedString(">\n"sv)));
 }
-(output += Jakt::DeprecatedString("{\n"sv));
+(output += ((Jakt::DeprecatedString("struct "sv) + name) + Jakt::DeprecatedString(" {\n"sv)));
+__jakt_var_585 = fields; goto __jakt_label_516;
+
+}
+__jakt_label_516:; __jakt_var_585.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> __jakt_var_586; {
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> fields = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({}))));
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> _magic = ((common_fields).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> field = (_magic_value.value());
 {
-(output += TRY((((*this).codegen_statement(statement)))));
+TRY((((fields).push(field))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString("}\n"sv));
-if (((((block).yielded_type)).has_value())){
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> const var_label_ = (((((*this).entered_yieldable_blocks)).pop()).value());
-DeprecatedString const var = ((var_label_).template get<0>());
-DeprecatedString const label = ((var_label_).template get<1>());
-
-(output += label);
-(output += Jakt::DeprecatedString(":; "sv));
-(output += var);
-if ((!(((block).yielded_none)))){
-(output += Jakt::DeprecatedString(".release_value()"sv));
-}
-(output += Jakt::DeprecatedString("; })"sv));
-}
-return (output);
-}
+TRY((((fields).push((Tuple{Jakt::DeprecatedString("value"sv), TRY((((*this).codegen_type(type_id))))})))));
+if (is_generic){
+(output += ((Jakt::DeprecatedString("template<"sv) + template_args) + Jakt::DeprecatedString(">\n"sv)));
 }
+(output += ((Jakt::DeprecatedString("struct "sv) + name) + Jakt::DeprecatedString("{\n"sv)));
+__jakt_var_586 = fields; goto __jakt_label_517;
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_checked_binary_op_assignment(NonnullRefPtr<typename types::CheckedExpression> const lhs,NonnullRefPtr<typename types::CheckedExpression> const rhs,parser::BinaryOperator const op,types::TypeId const type_id) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += Jakt::DeprecatedString("{"sv));
-(output += Jakt::DeprecatedString("auto& _jakt_ref = "sv));
-(output += TRY((((*this).codegen_expression(lhs)))));
-(output += Jakt::DeprecatedString(";"sv));
-(output += Jakt::DeprecatedString("_jakt_ref = JaktInternal::"sv));
-(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 27: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_add"sv));
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_sub"sv));
-};/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_mul"sv));
-};/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_div"sv));
-};/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("checked_mod"sv));
+}
+__jakt_label_517:; __jakt_var_586.release_value(); }));
 };/*case end*/
 default: {
-{
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Checked binary operation assignment codegen is not supported for BinaryOperator::{}"sv),op))));
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> __jakt_var_587; {
+utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen enum variant: {}"sv),variant))));
+__jakt_var_587 = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({})))); goto __jakt_label_518;
+
 }
+__jakt_label_518:; __jakt_var_587.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
-)));
-(output += Jakt::DeprecatedString("<"sv));
-(output += TRY((((*this).codegen_type(type_id)))));
-(output += Jakt::DeprecatedString(">(_jakt_ref, "sv));
-(output += TRY((((*this).codegen_expression(rhs)))));
-(output += Jakt::DeprecatedString(");"sv));
-(output += Jakt::DeprecatedString("}"sv));
-return (output);
+));
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> _magic = ((fields).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> name__type__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> const jakt__name__type__ = name__type__;
+DeprecatedString const name = ((jakt__name__type__).template get<0>());
+DeprecatedString const type = ((jakt__name__type__).template get<1>());
+
+(output += TRY((__jakt_format(Jakt::DeprecatedString("{} {};\n"sv),type,name))));
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum_type(types::EnumId const id,bool const as_namespace) const {
+}
+}
+
+if ((!(((fields).is_empty())))){
+(output += Jakt::DeprecatedString("template<"sv));
+JaktInternal::DynamicArray<DeprecatedString> generic_typenames = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+JaktInternal::DynamicArray<DeprecatedString> generic_argument_types = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+JaktInternal::DynamicArray<DeprecatedString> initializers = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-NonnullRefPtr<types::Module> const type_module = ((((*this).program))->get_module(((id).module)));
-types::CheckedEnum const checked_enum = ((((*this).program))->get_enum(id));
-if (((!(as_namespace)) && ((checked_enum).is_boxed))){
-(output += Jakt::DeprecatedString("NonnullRefPtr<"sv));
-DeprecatedString const qualifier = TRY((((*this).codegen_namespace_qualifier(((checked_enum).scope_id),true,JaktInternal::OptionalNone()))));
-if ((!(((qualifier).is_empty())))){
-(output += Jakt::DeprecatedString("typename "sv));
-(output += qualifier);
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((fields).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-(output += ((checked_enum).name));
-(output += Jakt::DeprecatedString(">"sv));
+size_t i = (_magic_value.value());
+{
+TRY((((generic_typenames).push(TRY((__jakt_format(Jakt::DeprecatedString("typename _MemberT{}"sv),i)))))));
+TRY((((generic_argument_types).push(TRY((__jakt_format(Jakt::DeprecatedString("_MemberT{}&& member_{}"sv),i,i)))))));
+DeprecatedString initializer = (((((fields)[i])).template get<0>()) + Jakt::DeprecatedString("{ forward<_MemberT"sv));
+(initializer += (TRY((__jakt_format(Jakt::DeprecatedString("{}>(member_{}"sv),i,i))) + Jakt::DeprecatedString(")}"sv)));
+TRY((((initializers).push(initializer))));
 }
-else {
-DeprecatedString const qualifier = TRY((((*this).codegen_namespace_qualifier(((checked_enum).scope_id),true,JaktInternal::OptionalNone()))));
-if ((!(((qualifier).is_empty())))){
-(output += qualifier);
+
 }
-(output += ((checked_enum).name));
 }
 
-return (output);
+(output += utility::join(generic_typenames,Jakt::DeprecatedString(", "sv)));
+(output += Jakt::DeprecatedString(">\n"sv));
+(output += (((((variant).name()) + Jakt::DeprecatedString("("sv)) + utility::join(generic_argument_types,Jakt::DeprecatedString(", "sv))) + Jakt::DeprecatedString("):\n"sv)));
+(output += (utility::join(initializers,Jakt::DeprecatedString(",\n"sv)) + Jakt::DeprecatedString("\n{}\n"sv)));
 }
+(output += Jakt::DeprecatedString("};\n"sv));
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_constructor(NonnullRefPtr<types::CheckedFunction> const function,bool const is_inline) {
-{
-types::TypeId const type_id = ((function)->return_type_id);
-NonnullRefPtr<typename types::Type> const type_ = ((((*this).program))->get_type(type_id));
-if (((type_)->index() == 23 /* Struct */)){
-types::StructId const struct_id = ((type_)->get<types::Type::Struct>()).value;
-types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
-DeprecatedString const qualified_name = TRY((((*this).codegen_type_possibly_as_namespace(type_id,true))));
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((!(is_inline)) && (!(((((structure).generic_parameters)).is_empty()))))){
-(output += Jakt::DeprecatedString("template <"sv));
-bool first = true;
+}
+}
+
+(output += Jakt::DeprecatedString("}\n"sv));
+if (is_generic){
+(output += ((Jakt::DeprecatedString("template<"sv) + template_args) + Jakt::DeprecatedString(">\n"sv)));
+}
+JaktInternal::DynamicArray<DeprecatedString> variant_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+JaktInternal::DynamicArray<DeprecatedString> variant_arguments_array = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((structure).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter param = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-if (first){
-(first = false);
-}
-else {
-(output += Jakt::DeprecatedString(","sv));
+DeprecatedString argument = ((((enum_).name) + Jakt::DeprecatedString("_Details::"sv)) + ((variant).name()));
+if (is_generic){
+(argument += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv))))));
 }
-
-(output += Jakt::DeprecatedString("typename "sv));
-(output += TRY((((*this).codegen_type(((param).type_id))))));
+TRY((((variant_arguments_array).push(argument))));
+TRY((((variant_names).push(((variant).name())))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(">\n"sv));
-}
-if (((((structure).record_type)).index() == 1 /* Class */)){
-if (is_inline){
-(output += ((function)->name_for_codegen()));
-(output += Jakt::DeprecatedString("("sv));
+DeprecatedString const variant_args = utility::join(variant_arguments_array,Jakt::DeprecatedString(", "sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {} : public Variant<{}>"sv),((enum_).name),variant_args))));
+if (((enum_).is_boxed)){
+(output += TRY((__jakt_format(Jakt::DeprecatedString(", public RefCounted<{}"sv),((enum_).name)))));
+if (is_generic){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv))))));
 }
-else {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("{}::{}("sv),qualified_name,((function)->name_for_codegen())))));
+(output += Jakt::DeprecatedString(">"sv));
 }
-
-bool first = true;
+(output += Jakt::DeprecatedString(" {\n"sv));
+(output += ((Jakt::DeprecatedString("using Variant<"sv) + variant_args) + Jakt::DeprecatedString(">::Variant;\n"sv)));
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((variant_names).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+DeprecatedString name = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
+(output += (((((Jakt::DeprecatedString("    using "sv) + name) + Jakt::DeprecatedString(" = "sv)) + ((enum_).name)) + Jakt::DeprecatedString("_Details::"sv)) + name));
+if (is_generic){
+(output += Jakt::DeprecatedString("<"sv));
+(output += utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv)));
+(output += Jakt::DeprecatedString(">"sv));
 }
-else {
-(first = false);
+(output += Jakt::DeprecatedString(";\n"sv));
 }
 
-types::TypeId const param_type_id = ((((param).variable))->type_id);
-(output += TRY((((*this).codegen_type(param_type_id)))));
-(output += Jakt::DeprecatedString(" a_"sv));
-(output += ((((param).variable))->name));
 }
-
 }
+
+if (((enum_).is_boxed)){
+DeprecatedString fully_instantiated_name = ((enum_).name);
+if (is_generic){
+(fully_instantiated_name += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv))))));
+}
+(output += Jakt::DeprecatedString("template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {\n"sv));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("return adopt_nonnull_ref_or_enomem(new (nothrow) {}(V(forward<Args>(args)...)));\n"sv),fully_instantiated_name))));
+(output += Jakt::DeprecatedString("}\n"sv));
+}
+if (((((enum_).generic_parameters)).is_empty())){
+(output += Jakt::DeprecatedString("ErrorOr<DeprecatedString> debug_description() const;\n"sv));
+}
+else {
+(output += TRY((((*this).codegen_enum_debug_description_getter(enum_,true)))));
 }
 
-(output += Jakt::DeprecatedString(")"sv));
-if ((!(((((function)->params)).is_empty())))){
-(output += Jakt::DeprecatedString(": "sv));
-JaktInternal::DynamicArray<DeprecatedString> initializers = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-size_t const parent_constructor_parameter_count = (JaktInternal::checked_sub<size_t>(((((function)->params)).size()),((((structure).fields)).size())));
-if ((parent_constructor_parameter_count > static_cast<size_t>(0ULL))){
-DeprecatedString parent_initializer = Jakt::DeprecatedString(""sv);
-(parent_initializer += ((((((*this).program))->get_struct((((structure).super_struct_id).value())))).name_for_codegen()));
-(parent_initializer += Jakt::DeprecatedString("("sv));
-JaktInternal::DynamicArray<DeprecatedString> strings = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((((function)->params))[(JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(parent_constructor_parameter_count)})])).iterator());
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> _magic = ((common_fields).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> field_name__type__ = (_magic_value.value());
 {
-TRY((((strings).push(((Jakt::DeprecatedString("move(a_"sv) + ((((param).variable))->name)) + Jakt::DeprecatedString(")"sv))))));
-}
-
-}
-}
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> const jakt__field_name__type__ = field_name__type__;
+DeprecatedString const field_name = ((jakt__field_name__type__).template get<0>());
+DeprecatedString const type = ((jakt__field_name__type__).template get<1>());
 
-(parent_initializer += utility::join(strings,Jakt::DeprecatedString(", "sv)));
-(parent_initializer += Jakt::DeprecatedString(")"sv));
-TRY((((initializers).push(parent_initializer))));
-}
+(output += TRY((__jakt_format(Jakt::DeprecatedString("{} const& {}() const {{ switch(this->index()) {{"sv),type,field_name))));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(parent_constructor_parameter_count),static_cast<size_t>(((((function)->params)).size()))});
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((enum_).variants)).size()))});
 for (;;){
 JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
@@ -5766,248 +5660,292 @@ break;
 }
 size_t i = (_magic_value.value());
 {
-types::CheckedParameter const param = ((((function)->params))[i]);
-TRY((((initializers).push((((((((param).variable))->name) + Jakt::DeprecatedString("(move(a_"sv)) + ((((param).variable))->name)) + Jakt::DeprecatedString("))"sv))))));
+types::CheckedEnumVariant const variant = ((((enum_).variants))[i]);
+DeprecatedString const name = ((variant).name());
+(output += TRY((__jakt_format(Jakt::DeprecatedString("case {} /* {} */: "sv),i,name))));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("return this->template get<{}::{}>().{};\n"sv),((enum_).name),name,field_name))));
 }
 
 }
 }
 
-(output += utility::join(initializers,Jakt::DeprecatedString(", "sv)));
+(output += Jakt::DeprecatedString("default: VERIFY_NOT_REACHED();\n"sv));
+(output += Jakt::DeprecatedString("}\n}\n"sv));
 }
-(output += Jakt::DeprecatedString("{}\n"sv));
-DeprecatedString class_name_with_generics = Jakt::DeprecatedString(""sv);
-(class_name_with_generics += ((structure).name_for_codegen()));
-(first = true);
+
+}
+}
+
+NonnullRefPtr<types::Scope> const enum_scope = TRY((((((*this).program))->get_scope(((enum_).scope_id)))));
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((structure).generic_parameters)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((enum_scope)->functions)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter generic_parameter = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-if ((!(first))){
-(class_name_with_generics += Jakt::DeprecatedString(", "sv));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
+
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::FunctionId function_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function_id = ((*this).current_function);
+(((*this).current_function) = static_cast<JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>>>(function));
+ScopeGuard __jakt_var_588([&] {
+(((*this).current_function) = previous_function_id);
+});
+if ((!(((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)))){
+if ((!(((((enum_).generic_parameters)).is_empty())))){
+(output += TRY((((*this).codegen_function(function,true)))));
+}
+else if ((((((((function)->generics))->params)).is_empty()) || (!(((((function)->specialization_index)).has_value()))))){
+(output += TRY((((*this).codegen_function_predecl(function,true,false)))));
+}
 }
 else {
-(class_name_with_generics += Jakt::DeprecatedString("<"sv));
-(first = false);
+continue;
 }
 
-(class_name_with_generics += TRY((((*this).codegen_type(((generic_parameter).type_id))))));
 }
 
 }
 }
 
-if ((!(((((structure).generic_parameters)).is_empty())))){
-(class_name_with_generics += Jakt::DeprecatedString(">"sv));
 }
-if (is_inline){
-(output += Jakt::DeprecatedString("static "sv));
+
 }
-DeprecatedString const qualified_namespace = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (is_inline);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
-else {
-return JaktInternal::ExplicitValue((qualified_name + Jakt::DeprecatedString("::"sv)));
+
+(output += Jakt::DeprecatedString("};\n"sv));
+(((*this).deferred_output) += TRY((((*this).codegen_ak_formatter(((enum_).name),generic_parameter_names)))));
+return (output);
 }
-}()))
-;
-(output += TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<NonnullRefPtr<{}>> {}__jakt_create"sv),class_name_with_generics,qualified_namespace))));
-(output += Jakt::DeprecatedString("("sv));
-(first = true);
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::CheckedParameter param = (_magic_value.value());
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_struct_type(types::StructId const id,bool const as_namespace) const {
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+NonnullRefPtr<types::Module> const type_module = ((((*this).program))->get_module(((id).module)));
+types::CheckedStruct const checked_struct = ((((*this).program))->get_struct(id));
+if (((!(as_namespace)) && ((((checked_struct).record_type)).index() == 1 /* Class */))){
+(output += Jakt::DeprecatedString("NonnullRefPtr<"sv));
+(output += TRY((((*this).codegen_namespace_qualifier(((checked_struct).scope_id),true,JaktInternal::OptionalNone())))));
+(output += ((checked_struct).name_for_codegen()));
+(output += Jakt::DeprecatedString(">"sv));
 }
 else {
-(first = false);
+(output += TRY((((*this).codegen_namespace_qualifier(((checked_struct).scope_id),true,JaktInternal::OptionalNone())))));
+(output += ((checked_struct).name_for_codegen()));
 }
 
-(output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
-(output += Jakt::DeprecatedString(" "sv));
-(output += ((((param).variable))->name));
+return (output);
+}
 }
 
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum_predecl(types::CheckedEnum const enum_) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((!(((((enum_).underlying_type_id)).equals(types::void_type_id()))))){
+if (((((*this).program))->is_integer(((enum_).underlying_type_id)))){
+return (TRY((__jakt_format(Jakt::DeprecatedString("enum class {}: {};"sv),((enum_).name),TRY((((*this).codegen_type(((enum_).underlying_type_id)))))))));
 }
+else {
+utility::todo(Jakt::DeprecatedString("Enums with a non-integer underlying type"sv));
 }
 
-(output += TRY((__jakt_format(Jakt::DeprecatedString(") {{ auto o = {}(adopt_nonnull_ref_or_enomem(new (nothrow) {} ("sv),TRY((((*this).current_error_handler()))),class_name_with_generics))));
-(first = true);
+}
+bool const is_generic = (!(((((enum_).generic_parameters)).is_empty())));
+JaktInternal::DynamicArray<DeprecatedString> template_args_array = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((enum_).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+types::CheckedGenericParameter generic_parameter = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
-}
-else {
-(first = false);
+if (((((((*this).program))->get_type(((generic_parameter).type_id))))->index() == 18 /* TypeVariable */)){
+DeprecatedString const name = ((((((*this).program))->get_type(((generic_parameter).type_id))))->get<types::Type::TypeVariable>()).name;
+TRY((((template_args_array).push((Jakt::DeprecatedString("typename "sv) + name)))));
 }
-
-(output += Jakt::DeprecatedString("move("sv));
-(output += ((((param).variable))->name));
-(output += Jakt::DeprecatedString(")"sv));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString("))); return o; }"sv));
-return (output);
-}
-if ((!(is_inline))){
-(output += qualified_name);
-(output += Jakt::DeprecatedString("::"sv));
-}
-(output += ((function)->name_for_codegen()));
-(output += Jakt::DeprecatedString("("sv));
-bool first = true;
+DeprecatedString template_args = utility::join(template_args_array,Jakt::DeprecatedString(", "sv));
+(output += (TRY((__jakt_format(Jakt::DeprecatedString("namespace {}_Details"sv),((enum_).name)))) + Jakt::DeprecatedString(" {\n"sv)));
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
+{
+if (is_generic){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>\n"sv),template_args))));
 }
-else {
-(first = false);
+(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {};\n"sv),name))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
+{
+if (is_generic){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>\n"sv),template_args))));
+}
+(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {};\n"sv),name))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
+{
+if (is_generic){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>\n"sv),template_args))));
+}
+(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {};\n"sv),name))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
 
-(output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
-(output += Jakt::DeprecatedString(" a_"sv));
-(output += ((((param).variable))->name));
+}
 }
 
+(output += Jakt::DeprecatedString("}\n"sv));
+if (is_generic){
+(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>\n"sv),template_args))));
+}
+(output += TRY((__jakt_format(Jakt::DeprecatedString("struct {};\n"sv),((enum_).name)))));
+return (output);
 }
 }
 
-(output += Jakt::DeprecatedString(") "sv));
-if ((!(((((function)->params)).is_empty())))){
-(output += Jakt::DeprecatedString(":"sv));
+ErrorOr<void> codegen::CodeGenerator::postorder_traversal(DeprecatedString const encoded_type_id,JaktInternal::Set<DeprecatedString> visited,JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const encoded_dependency_graph,JaktInternal::DynamicArray<types::TypeId> output) const {
+{
+types::TypeId const type_id = TRY((types::TypeId::from_string(encoded_type_id)));
+if (((visited).contains(TRY((((type_id).to_string())))))){
+return {};
 }
-(first = true);
+TRY((((visited).add(TRY((((type_id).to_string())))))));
+if (((encoded_dependency_graph).contains(encoded_type_id))){
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = (((((encoded_dependency_graph).get(encoded_type_id)).value())).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+DeprecatedString dependency = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
-}
-else {
-(first = false);
-}
-
-(output += ((((param).variable))->name));
-(output += Jakt::DeprecatedString("(move(a_"sv));
-(output += ((((param).variable))->name));
-(output += Jakt::DeprecatedString("))"sv));
+TRY((((*this).postorder_traversal(dependency,visited,encoded_dependency_graph,output))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString("{}\n"sv));
-return (output);
-}
-else {
-utility::panic(Jakt::DeprecatedString("internal error: call to a constructor, but not a struct/class type"sv));
 }
-
+TRY((((output).push(type_id))));
 }
+return {};
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum_debug_description_getter(types::CheckedEnum const enum_,bool const is_inline) {
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> codegen::CodeGenerator::extract_dependencies_from_enum(types::EnumId const enum_id,JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph,bool const top_level) const {
 {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if (((!(is_inline)) && (!(((((enum_).generic_parameters)).is_empty()))))){
-(output += Jakt::DeprecatedString("template <"sv));
-bool first = true;
+JaktInternal::DynamicArray<DeprecatedString> dependencies = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+if (((((enum_).definition_linkage)).index() == 1 /* External */)){
+return (dependencies);
+}
+if ((((enum_).is_boxed) && (!(top_level)))){
+return (dependencies);
+}
+TRY((((dependencies).push(TRY((((((enum_).type_id)).to_string())))))));
+if ((!(((((enum_).underlying_type_id)).equals(types::unknown_type_id()))))){
+JaktInternal::DynamicArray<DeprecatedString> const inner_dependencies = TRY((((*this).extract_dependencies_from(((enum_).underlying_type_id),dependency_graph,false))));
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((enum_).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((inner_dependencies).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter param = (_magic_value.value());
+DeprecatedString dependency = (_magic_value.value());
 {
-if (first){
-(first = false);
-}
-else {
-(output += Jakt::DeprecatedString(","sv));
-}
-
-(output += Jakt::DeprecatedString("typename "sv));
-(output += TRY((((*this).codegen_type(((param).type_id))))));
+TRY((((dependencies).push(dependency))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(">\n"sv));
-}
-(output += Jakt::DeprecatedString("ErrorOr<DeprecatedString> "sv));
-if ((!(is_inline))){
-(output += TRY((((*this).codegen_type_possibly_as_namespace(((enum_).type_id),true)))));
-(output += Jakt::DeprecatedString("::"sv));
 }
-(output += Jakt::DeprecatedString("debug_description() const {\n"sv));
-(output += Jakt::DeprecatedString("auto builder = TRY(DeprecatedStringBuilder::create());\n"sv));
-(output += Jakt::DeprecatedString("switch (this->index()) {"sv));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((enum_).variants)).size()))});
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-types::CheckedEnumVariant const variant = ((((enum_).variants))[i]);
-DeprecatedString const name = ((variant).name());
-(output += TRY((__jakt_format(Jakt::DeprecatedString("case {} /* {} */: {{\n"sv),i,name))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<DeprecatedString>>>{
 auto&& __jakt_match_variant = variant;
 switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();types::TypeId const& type_id = __jakt_match_value.type_id;
+{
+JaktInternal::DynamicArray<DeprecatedString> const inner_dependencies = TRY((((*this).extract_dependencies_from(type_id,dependency_graph,false))));
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((inner_dependencies).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+DeprecatedString dependency = (_magic_value.value());
+{
+TRY((((dependencies).push(dependency))));
+}
+
+}
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
 {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.append(\"{}::{}\"sv));\n"sv),((enum_).name),name))));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("[[maybe_unused]] auto const& that = this->template get<{}::{}>();\n"sv),((enum_).name),name))));
-(output += Jakt::DeprecatedString("TRY(builder.append(\"(\"sv));\n"sv));
-(output += Jakt::DeprecatedString("{\n"sv));
-(output += Jakt::DeprecatedString("JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};\n"sv));
-size_t i = static_cast<size_t>(0ULL);
 {
 JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
 for (;;){
@@ -6017,39 +5955,26 @@ break;
 }
 types::VarId field = (_magic_value.value());
 {
-(output += Jakt::DeprecatedString("TRY(JaktInternal::PrettyPrint::output_indentation(builder));\n"sv));
-NonnullRefPtr<types::CheckedVariable> const var = ((((*this).program))->get_variable(field));
-if (((((*this).program))->is_string(((var)->type_id)))){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.appendff(\"{}: \\\"{{}}\\\"\", that.{}));\n"sv),((var)->name),((var)->name)))));
+types::TypeId const type_id = ((((((*this).program))->get_variable(field)))->type_id);
+JaktInternal::DynamicArray<DeprecatedString> const inner_dependencies = TRY((((*this).extract_dependencies_from(type_id,dependency_graph,false))));
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((inner_dependencies).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.appendff(\"{}: {{}}\", that.{}));\n"sv),((var)->name),((var)->name)))));
+DeprecatedString dependency = (_magic_value.value());
+{
+TRY((((dependencies).push(dependency))));
 }
 
-if ((i != (JaktInternal::checked_sub<size_t>(((fields).size()),static_cast<size_t>(1ULL))))){
-(output += Jakt::DeprecatedString("TRY(builder.append(\", \"sv));\n"sv));
 }
-((i++));
 }
 
-}
 }
 
-(output += Jakt::DeprecatedString("}\n"sv));
-(output += Jakt::DeprecatedString("TRY(builder.append(\")\"sv));\n"sv));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();types::TypeId const& type_id = __jakt_match_value.type_id;
-{
-(output += TRY((__jakt_format(Jakt::DeprecatedString("TRY(builder.append(\"{}::{}\"sv));\n"sv),((enum_).name),name))));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("[[maybe_unused]] auto const& that = this->template get<{}::{}>();\n"sv),((enum_).name),name))));
-if (((((*this).program))->is_string(type_id))){
-(output += Jakt::DeprecatedString("TRY(builder.appendff(\"(\\\"{}\\\")\", that.value));\n"sv));
 }
-else {
-(output += Jakt::DeprecatedString("TRY(builder.appendff(\"({})\", that.value));\n"sv));
 }
 
 }
@@ -6057,1137 +5982,1091 @@ return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("return DeprecatedString(\"{}::{}\"sv);\n"sv),((enum_).name),name))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-(output += Jakt::DeprecatedString("break;}\n"sv));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString("}\nreturn builder.to_string();\n}\n"sv));
-return (output);
+return (dependencies);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_enum_match(types::CheckedEnum const enum_,NonnullRefPtr<typename types::CheckedExpression> const expr,JaktInternal::DynamicArray<types::CheckedMatchCase> const match_cases,types::TypeId const type_id,bool const all_variants_constant) {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_generic_enum_instance(types::EnumId const id,JaktInternal::DynamicArray<types::TypeId> const args,bool const as_namespace) const {
 {
 DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += ((((*this).control_flow_state)).choose_control_flow_macro()));
-DeprecatedString const subject = TRY((((*this).codegen_expression(expr))));
-bool const needs_deref = (((enum_).is_boxed) && (subject != Jakt::DeprecatedString("*this"sv)));
-if (((((enum_).underlying_type_id)).equals(types::void_type_id()))){
-(output += Jakt::DeprecatedString("(([&]() -> JaktInternal::ExplicitValueOrControlFlow<"sv));
-(output += TRY((((*this).codegen_type(type_id)))));
-(output += Jakt::DeprecatedString(", "sv));
-(output += TRY((((*this).codegen_function_return_type((((*this).current_function).value()))))));
-(output += Jakt::DeprecatedString(">{\n"sv));
-(output += Jakt::DeprecatedString("auto&& __jakt_match_variant = "sv));
-if (needs_deref){
-(output += Jakt::DeprecatedString("*"sv));
-}
-(output += (TRY((((*this).codegen_expression(expr)))) + Jakt::DeprecatedString(";\n"sv)));
-(output += Jakt::DeprecatedString("switch(__jakt_match_variant.index()) {\n"sv));
-bool has_default = false;
-{
-JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedMatchCase> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedMatchCase match_case = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = match_case;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::EnumVariant>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& args = __jakt_match_value.args;
-types::TypeId const& subject_type_id = __jakt_match_value.subject_type_id;
-size_t const& index = __jakt_match_value.index;
-types::ScopeId const& scope_id = __jakt_match_value.scope_id;
-types::CheckedMatchBody const& body = __jakt_match_value.body;
-{
-NonnullRefPtr<typename types::Type> const enum_type = ((((*this).program))->get_type(subject_type_id));
-types::EnumId const enum_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *enum_type;
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(id);
-};/*case end*/
-default: {
-{
-utility::panic(Jakt::DeprecatedString("Expected enum type"sv));
+bool close_tag = false;
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(id));
+if (((!(as_namespace)) && ((enum_).is_boxed))){
+(output += Jakt::DeprecatedString("NonnullRefPtr<"sv));
+DeprecatedString const qualifier = TRY((((*this).codegen_namespace_qualifier(((enum_).scope_id),true,JaktInternal::OptionalNone()))));
+if ((!(((qualifier).is_empty())))){
+(output += Jakt::DeprecatedString("typename "sv));
+(output += qualifier);
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-types::CheckedEnum const match_case_enum = ((((*this).program))->get_enum(enum_id));
-types::CheckedEnumVariant const variant = ((((match_case_enum).variants))[index]);
-(output += (TRY((__jakt_format(Jakt::DeprecatedString("case {}: "sv),index))) + Jakt::DeprecatedString("{\n"sv)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
-{
+(output += ((enum_).name));
+(close_tag = true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-{
-if ((!(((args).is_empty())))){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("auto&& __jakt_match_value = __jakt_match_variant.template get<typename {}::{}>();\n"sv),TRY((((*this).codegen_type_possibly_as_namespace(subject_type_id,true)))),name))));
-parser::EnumVariantPatternArgument const arg = ((args)[static_cast<i64>(0LL)]);
-NonnullRefPtr<types::CheckedVariable> const var = (TRY((((((*this).program))->find_var_in_scope(scope_id,((arg).binding))))).value());
-(output += TRY((((*this).codegen_type(((var)->type_id))))));
-if ((!(((var)->is_mutable)))){
-(output += Jakt::DeprecatedString(" const"sv));
+else {
+DeprecatedString const qualifier = TRY((((*this).codegen_namespace_qualifier(((enum_).scope_id),true,JaktInternal::OptionalNone()))));
+if ((!(((qualifier).is_empty())))){
+if ((!(as_namespace))){
+(output += Jakt::DeprecatedString("typename "sv));
 }
-(output += Jakt::DeprecatedString("& "sv));
-(output += ((arg).binding));
-(output += Jakt::DeprecatedString(" = __jakt_match_value.value;\n"sv));
+(output += qualifier);
 }
+(output += ((enum_).name));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
-{
-if ((!(((args).is_empty())))){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("auto&& __jakt_match_value = __jakt_match_variant.template get<{}::{}>();"sv),TRY((((*this).codegen_type_possibly_as_namespace(subject_type_id,true)))),name))));
+
+(output += Jakt::DeprecatedString("<"sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = ((args).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
 for (;;){
-JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::EnumVariantPatternArgument arg = (_magic_value.value());
+types::TypeId type_id = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedVariable> const var = (TRY((((((*this).program))->find_var_in_scope(scope_id,((arg).binding))))).value());
-(output += TRY((((*this).codegen_type(((var)->type_id))))));
-if ((!(((var)->is_mutable)))){
-(output += Jakt::DeprecatedString(" const"sv));
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
-(output += Jakt::DeprecatedString("& "sv));
-(output += ((arg).binding));
-(output += Jakt::DeprecatedString(" = __jakt_match_value."sv));
-(output += ((((arg).name)).value_or(((arg).binding))));
-(output += Jakt::DeprecatedString(";\n"sv));
+else {
+(first = false);
+}
+
+(output += TRY((((*this).codegen_type(type_id)))));
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString(">"sv));
+if (close_tag){
+(output += Jakt::DeprecatedString(">"sv));
 }
+return (output);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("codegen_enum_match match variant else: {}"sv),variant))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function_return_type(NonnullRefPtr<types::CheckedFunction> const function) {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((match_case).defaults())).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if ((((function)->is_static()) && (((function)->name_for_codegen()) == Jakt::DeprecatedString("main"sv)))){
+return (Jakt::DeprecatedString("ErrorOr<int>"sv));
 }
-NonnullRefPtr<typename types::CheckedStatement> default_ = (_magic_value.value());
+DeprecatedString const type_name = TRY((((*this).codegen_type(((function)->return_type_id)))));
+if (((function)->can_throw)){
+return (TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),type_name))));
+}
+return (type_name);
+}
+}
+
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function_in_namespace(NonnullRefPtr<types::CheckedFunction> const function,JaktInternal::Optional<types::TypeId> const containing_struct,bool const as_method,bool const skip_template,JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const explicit_generic_instantiation) {
 {
-(output += TRY((((*this).codegen_statement(default_)))));
+if ((!(((((((function)->generics))->params)).is_empty())))){
+if (((((function)->linkage)).index() == 1 /* External */)){
+return (Jakt::DeprecatedString(""sv));
+}
+}
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((!(skip_template))){
+(output += TRY((((*this).codegen_function_generic_parameters(function)))));
+}
+bool const is_main = ((((function)->name_for_codegen()) == Jakt::DeprecatedString("main"sv)) && (!(((containing_struct).has_value()))));
+if (((((function)->return_type_id)).equals(types::never_type_id()))){
+(output += Jakt::DeprecatedString("[[noreturn]] "sv));
+}
+if (is_main){
+(output += Jakt::DeprecatedString("ErrorOr<int>"sv));
+}
+else {
+if ((as_method && ((function)->is_static()))){
+(output += Jakt::DeprecatedString("static "sv));
+}
+if ((!(((((function)->type)).index() == 1 /* Destructor */)))){
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((function)->can_throw));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),TRY((((*this).codegen_type(((function)->return_type_id)))))))));
+}
+else {
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(((function)->return_type_id))))));
+}
+}()))
+);
+}
+}
+
+(output += Jakt::DeprecatedString(" "sv));
+if (is_main){
+(output += Jakt::DeprecatedString("main"sv));
+}
+else {
+DeprecatedString const qualifier = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (((containing_struct).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_type_possibly_as_namespace((containing_struct.value()),true)))));
+}
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+}
+}()))
+;
+if ((!(((qualifier).is_empty())))){
+(output += qualifier);
+(output += Jakt::DeprecatedString("::"sv));
+}
+if (((((function)->type)).index() == 1 /* Destructor */)){
+if (((((((*this).program))->get_type((containing_struct.value()))))->index() == 23 /* Struct */)){
+types::StructId const struct_id = ((((((*this).program))->get_type((containing_struct.value()))))->get<types::Type::Struct>()).value;
+(output += (Jakt::DeprecatedString("~"sv) + ((((((*this).program))->get_struct(struct_id))).name_for_codegen())));
+}
+else {
+utility::panic(Jakt::DeprecatedString("Destructor doesn't have a containing struct"sv));
 }
 
 }
+else {
+(output += ((function)->name_for_codegen()));
 }
 
-(output += TRY((((*this).codegen_match_body(body,type_id)))));
-(output += Jakt::DeprecatedString("};/*case end*/\n"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
-{
-(has_default = true);
-(output += Jakt::DeprecatedString("default: {\n"sv));
+
+if (((explicit_generic_instantiation).has_value())){
+(output += Jakt::DeprecatedString("<"sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((match_case).defaults())).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = (((explicit_generic_instantiation.value())).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename types::CheckedStatement> default_ = (_magic_value.value());
+types::TypeId type = (_magic_value.value());
 {
-(output += TRY((((*this).codegen_statement(default_)))));
-}
-
+if ((!(first))){
+(output += Jakt::DeprecatedString(", "sv));
 }
+else {
+(first = false);
 }
 
-(output += TRY((((*this).codegen_match_body(body,type_id)))));
-(output += Jakt::DeprecatedString("};/*case end*/\n"sv));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-utility::panic(Jakt::DeprecatedString("Matching enum subject with non-enum value"sv));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+(output += TRY((((*this).codegen_type(type)))));
 }
 
 }
 }
 
-if ((!(has_default))){
-if ((((((enum_).variants)).size()) != ((match_cases).size()))){
-utility::panic(Jakt::DeprecatedString("Inexhaustive match statement"sv));
-}
-(output += Jakt::DeprecatedString("default: VERIFY_NOT_REACHED();"sv));
+(output += Jakt::DeprecatedString(">"sv));
 }
-(output += Jakt::DeprecatedString("}/*switch end*/\n"sv));
-(output += Jakt::DeprecatedString("}()\n))"sv));
+(output += Jakt::DeprecatedString("("sv));
+if ((is_main && ((((function)->params)).is_empty()))){
+(output += Jakt::DeprecatedString("DynamicArray<DeprecatedString>"sv));
 }
-else {
-(output += Jakt::DeprecatedString("(([&]() -> JaktInternal::ExplicitValueOrControlFlow<"sv));
-(output += TRY((((*this).codegen_type(type_id)))));
-(output += Jakt::DeprecatedString(", "sv));
-(output += TRY((((*this).codegen_function_return_type((((*this).current_function).value()))))));
-(output += Jakt::DeprecatedString(">{\n"sv));
-(output += ((Jakt::DeprecatedString("switch ("sv) + TRY((((*this).codegen_expression(expr))))) + Jakt::DeprecatedString(") {\n"sv)));
+bool first = true;
 {
-JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedMatchCase> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedMatchCase match_case = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = match_case;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::EnumVariant>();DeprecatedString const& name = __jakt_match_value.name;
-types::CheckedMatchBody const& body = __jakt_match_value.body;
-{
-(output += ((((Jakt::DeprecatedString("case "sv) + ((enum_).name)) + Jakt::DeprecatedString("::"sv)) + name) + Jakt::DeprecatedString(": {\n"sv)));
-(output += TRY((((*this).codegen_match_body(body,type_id)))));
-(output += Jakt::DeprecatedString("}\n"sv));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
+types::CheckedParameter param = (_magic_value.value());
 {
-(output += Jakt::DeprecatedString("default: {\n"sv));
-(output += TRY((((*this).codegen_match_body(body,type_id)))));
-(output += Jakt::DeprecatedString("}\n"sv));
+NonnullRefPtr<types::CheckedVariable> const variable = ((param).variable);
+if ((((variable)->name) == Jakt::DeprecatedString("this"sv))){
+continue;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-utility::todo(TRY((__jakt_format(Jakt::DeprecatedString("underlying type enum match, match_case: {}"sv),match_case))));
+if ((!(first))){
+(output += Jakt::DeprecatedString(","sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+else {
+(first = false);
 }
 
+NonnullRefPtr<typename types::Type> const variable_type = ((((*this).program))->get_type(((variable)->type_id)));
+(output += TRY((((*this).codegen_type(((variable)->type_id))))));
+(output += Jakt::DeprecatedString(" "sv));
+if (((!(((variable)->is_mutable))) && (!((((variable_type)->index() == 27 /* Reference */) || ((variable_type)->index() == 28 /* MutableReference */)))))){
+(output += Jakt::DeprecatedString("const "sv));
 }
+(output += ((variable)->name));
 }
 
-(output += Jakt::DeprecatedString("}/*switch end*/\n"sv));
-(output += Jakt::DeprecatedString("}()\n))"sv));
-}
-
-return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_lambda_block(bool const can_throw,types::CheckedBlock const block,types::TypeId const return_type_id) {
-{
-DeprecatedString output = Jakt::DeprecatedString("{\n"sv);
-(output += TRY((((*this).codegen_block(block)))));
-if ((can_throw && ((return_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } ))))){
-(output += Jakt::DeprecatedString("return {};\n"sv));
-}
-(output += Jakt::DeprecatedString("}\n"sv));
-return (output);
+(output += Jakt::DeprecatedString(")"sv));
+if (((!(((function)->is_static()))) && (!(((function)->is_mutating()))))){
+(output += Jakt::DeprecatedString(" const"sv));
 }
+(output += Jakt::DeprecatedString(" {\n"sv));
+if (is_main){
+(output += Jakt::DeprecatedString("\n\n            #ifdef _WIN32\n            SetConsoleOutputCP(CP_UTF8);\n            // Enable buffering to prevent VS from chopping up UTF-8 byte sequences\n            setvbuf(stdout, nullptr, _IOFBF, 1000);\n            #endif\n"sv));
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_match(NonnullRefPtr<typename types::CheckedExpression> const expr,JaktInternal::DynamicArray<types::CheckedMatchCase> const match_cases,types::TypeId const type_id,bool const all_variants_constant) {
-{
 codegen::ControlFlowState const last_control_flow = ((*this).control_flow_state);
-(((*this).control_flow_state) = ((((*this).control_flow_state)).enter_match()));
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-NonnullRefPtr<typename types::Type> const expr_type = ((((*this).program))->get_type(((expr)->type())));
-if (((expr_type)->index() == 24 /* Enum */)){
-types::EnumId const enum_id = ((expr_type)->get<types::Type::Enum>()).value;
-(output += TRY((((*this).codegen_enum_match(((((*this).program))->get_enum(enum_id)),expr,match_cases,type_id,all_variants_constant)))));
+(((*this).control_flow_state) = ((last_control_flow).enter_function()));
+DeprecatedString const block = TRY((((*this).codegen_block(((function)->block)))));
+(((*this).control_flow_state) = last_control_flow);
+(output += block);
+if (is_main){
+(output += Jakt::DeprecatedString("return 0;\n"sv));
 }
 else {
-(output += TRY((((*this).codegen_generic_match(expr,match_cases,type_id,all_variants_constant)))));
+if ((((function)->can_throw) && ((((function)->return_type_id)).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } ))))){
+(output += Jakt::DeprecatedString("return {};\n"sv));
+}
 }
 
-(((*this).control_flow_state) = last_control_flow);
+(output += Jakt::DeprecatedString("}\n"sv));
 return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function_return_type(NonnullRefPtr<types::CheckedFunction> const function) {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_type(types::TypeId const type_id) const {
 {
-if ((((function)->is_static()) && (((function)->name_for_codegen()) == Jakt::DeprecatedString("main"sv)))){
-return (Jakt::DeprecatedString("ErrorOr<int>"sv));
-}
-DeprecatedString const type_name = TRY((((*this).codegen_type(((function)->return_type_id)))));
-if (((function)->can_throw)){
-return (TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),type_name))));
-}
-return (type_name);
+return (TRY((((*this).codegen_type_possibly_as_namespace(type_id,false)))));
 }
 }
 
-ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> codegen::CodeGenerator::generate(NonnullRefPtr<compiler::Compiler> const compiler,NonnullRefPtr<types::CheckedProgram> const program,bool const debug_info) {
-{
-codegen::CodeGenerator generator = codegen::CodeGenerator(compiler,program,codegen::ControlFlowState( codegen::AllowedControlExits { typename codegen::AllowedControlExits::Nothing() } ,false,false,static_cast<size_t>(0ULL)),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with({})))),Jakt::DeprecatedString(""sv),JaktInternal::OptionalNone(),false,codegen::CodegenDebugInfo(compiler,(TRY((Dictionary<size_t, JaktInternal::DynamicArray<codegen::LineSpan>>::create_with_entries({})))),debug_info),(TRY((DynamicArray<DeprecatedString>::create_with({})))),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL));
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>> result = (TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<DeprecatedString,DeprecatedString>>::create_with_entries({}))));
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += Jakt::DeprecatedString("#pragma once\n"sv));
-(output += Jakt::DeprecatedString("#include <lib.h>\n"sv));
-(output += Jakt::DeprecatedString("#ifdef _WIN32\n"sv));
-(output += Jakt::DeprecatedString("extern \"C\" __cdecl int SetConsoleOutputCP(unsigned int code_page);\n"sv));
-(output += Jakt::DeprecatedString("const unsigned int CP_UTF8 = 65001;\n"sv));
-(output += Jakt::DeprecatedString("#endif\n"sv));
-JaktInternal::DynamicArray<types::ModuleId> const sorted_modules = TRY((((generator).topologically_sort_modules())));
-(output += Jakt::DeprecatedString("namespace Jakt {\n"sv));
+ErrorOr<JaktInternal::Optional<DeprecatedString>> codegen::CodeGenerator::codegen_namespace_specialization(types::FunctionId const function_id,JaktInternal::Optional<types::TypeId> const containing_struct,NonnullRefPtr<types::Scope> const scope,NonnullRefPtr<types::Module> const current_module,bool const define_pass) {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(((sorted_modules).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+if ((!(((((((function)->function_scope_id)).module_id)).equals(((current_module)->id)))))){
+return (JaktInternal::OptionalNone());
 }
-size_t idx = (_magic_value.value());
-{
-size_t const i = ((((sorted_modules)[(JaktInternal::checked_sub<size_t>(idx,static_cast<size_t>(1ULL)))])).id);
-if ((i == static_cast<size_t>(0ULL))){
-continue;
+if (((function)->is_comptime)){
+return (JaktInternal::OptionalNone());
 }
-NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[i]);
-((((generator).compiler))->dbg_println(TRY((__jakt_format(Jakt::DeprecatedString("generate: module idx: {}, module.name {}"sv),i,((module)->name))))));
-types::ScopeId const scope_id = types::ScopeId(((module)->id),static_cast<size_t>(0ULL));
-NonnullRefPtr<types::Scope> const scope = TRY((((((generator).program))->get_scope(scope_id))));
-(output += TRY((((generator).codegen_namespace_predecl(scope,module)))));
+JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
+(((*this).current_function) = function);
+ScopeGuard __jakt_var_589([&] {
+(((*this).current_function) = previous_function);
+});
+if ((((((((function)->linkage)).index() == 1 /* External */) || ((((function)->type)).index() == 2 /* ImplicitConstructor */)) || ((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)) || ((((function)->type)).index() == 1 /* Destructor */))){
+return (JaktInternal::OptionalNone());
 }
-
+if ((((((((function)->generics))->params)).is_empty()) || (!(((((function)->specialization_index)).has_value()))))){
+return (JaktInternal::OptionalNone());
 }
+if ((((containing_struct).has_value()) && (!(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<JaktInternal::Optional<DeprecatedString>>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type((containing_struct.value())));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((((((*this).program))->get_struct(struct_id))).generic_parameters)).is_empty()));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& struct_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((((((*this).program))->get_enum(struct_id))).generic_parameters)).is_empty()));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)))))){
+return (JaktInternal::OptionalNone());
 }
-
-(output += Jakt::DeprecatedString("} // namespace Jakt\n"sv));
-TRY((((result).set(Jakt::DeprecatedString("__unified_forward.h"sv),(Tuple{output, (((((compiler)->current_file_path()).value())).to_string())})))));
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+bool const is_full_respecialization = ((*this).is_full_respecialization(((((((function)->generics))->specializations))[(((function)->specialization_index).value())])));
+if ((define_pass && is_full_respecialization)){
+(output = Jakt::DeprecatedString("template<"sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<bool> _magic = (((TRY((DynamicArray<bool>::create_with({true, false}))))).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((((((((function)->generics))->specializations))[(((function)->specialization_index).value())])).iterator());
 for (;;){
-JaktInternal::Optional<bool> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-bool as_forward = (_magic_value.value());
-{
+types::TypeId arg = (_magic_value.value());
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(((sorted_modules).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((((((*this).program))->get_type(arg)))->index() == 18 /* TypeVariable */)){
+DeprecatedString const name = ((((((*this).program))->get_type(arg)))->get<types::Type::TypeVariable>()).name;
+if (first){
+(first = false);
 }
-size_t idx = (_magic_value.value());
-{
-size_t const i = ((((sorted_modules)[(JaktInternal::checked_sub<size_t>(idx,static_cast<size_t>(1ULL)))])).id);
-if ((i == static_cast<size_t>(0ULL))){
-continue;
+else {
+(output += Jakt::DeprecatedString(", "sv));
 }
-NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[i]);
-((((generator).compiler))->dbg_println(TRY((__jakt_format(Jakt::DeprecatedString("generate: module idx: {}, module.name {} - forward: {}"sv),i,((module)->name),as_forward)))));
-DeprecatedString const header_name = TRY((__jakt_format(Jakt::DeprecatedString("{}.h"sv),((module)->name))));
-DeprecatedString const impl_name = TRY((__jakt_format(Jakt::DeprecatedString("{}.cpp"sv),((module)->name))));
-if (as_forward){
-(output = Jakt::DeprecatedString("#pragma once\n"sv));
-(output += Jakt::DeprecatedString("#include \"__unified_forward.h\"\n"sv));
+
+(output += TRY((__jakt_format(Jakt::DeprecatedString("typename {}"sv),name))));
 }
-else {
-(output = TRY((__jakt_format(Jakt::DeprecatedString("#include \"{}\"\n"sv),header_name))));
 }
 
-types::ScopeId const scope_id = types::ScopeId(((module)->id),static_cast<size_t>(0ULL));
-NonnullRefPtr<types::Scope> const scope = TRY((((((generator).program))->get_scope(scope_id))));
-if (as_forward){
-{
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
-for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::ScopeId child_scope_id = (_magic_value.value());
-{
-NonnullRefPtr<types::Scope> const scope = TRY((((((generator).program))->get_scope(child_scope_id))));
-if (((((scope)->import_path_if_extern)).has_value())){
-bool const has_name = ((((scope)->namespace_name)).has_value());
-if (has_name){
-(output += TRY((__jakt_format(Jakt::DeprecatedString("namespace {} {{\n"sv),(((scope)->namespace_name).value())))));
 }
+
+(output += Jakt::DeprecatedString(">\n"sv));
+(output += TRY((((*this).codegen_function_in_namespace(function,containing_struct,false,true,((((((function)->generics))->specializations))[(((function)->specialization_index).value())]))))));
+}
+else if (is_full_respecialization){
+JaktInternal::DynamicArray<DeprecatedString> args = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<parser::IncludeAction> _magic = ((((scope)->before_extern_include)).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((((((((function)->generics))->specializations))[(((function)->specialization_index).value())])).iterator());
 for (;;){
-JaktInternal::Optional<parser::IncludeAction> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::IncludeAction action = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>>>>{
-auto&& __jakt_match_variant = action;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::IncludeAction::Define>();DeprecatedString const& name = __jakt_match_value.name;
-DeprecatedString const& value = __jakt_match_value.value;
+types::TypeId arg = (_magic_value.value());
 {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#ifdef {}\n"sv),name))));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#undef {}\n"sv),name))));
-(output += Jakt::DeprecatedString("#endif\n"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#define {} {}\n"sv),name,value))));
+TRY((((args).push(TRY((((*this).codegen_type(arg))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::IncludeAction::Undefine>();DeprecatedString const& name = __jakt_match_value.name;
-{
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#ifdef {}\n"sv),name))));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#undef {}\n"sv),name))));
-(output += Jakt::DeprecatedString("#endif\n"sv));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
 }
 
+(output += TRY((__jakt_format(Jakt::DeprecatedString("\n/* specialisation {} of function {}: {} */"sv),(((function)->specialization_index).value()),((function)->name),args))));
+(output += Jakt::DeprecatedString("\ntemplate<> "sv));
+if (((((function)->return_type_id)).equals(types::never_type_id()))){
+(output += Jakt::DeprecatedString("[[noreturn]] "sv));
 }
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<JaktInternal::Optional<DeprecatedString>>>{
+auto __jakt_enum_value = (((function)->can_throw));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<{}>"sv),TRY((((*this).codegen_type(((function)->return_type_id)))))))));
 }
-
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#include <{}>\n"sv),(((scope)->import_path_if_extern).value())))));
+else {
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_type(((function)->return_type_id))))));
+}
+}()))
+);
+(output += Jakt::DeprecatedString(" "sv));
+DeprecatedString const qualifier = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<JaktInternal::Optional<DeprecatedString>>>{
+auto __jakt_enum_value = (((containing_struct).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_type_possibly_as_namespace((containing_struct.value()),true)))));
+}
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+}
+}()))
+;
+if ((!(((qualifier).is_empty())))){
+(output += qualifier);
+(output += Jakt::DeprecatedString("::"sv));
+}
+(output += ((function)->name_for_codegen()));
+(output += Jakt::DeprecatedString("<"sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<parser::IncludeAction> _magic = ((((scope)->after_extern_include)).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((((((((function)->generics))->specializations))[(((function)->specialization_index).value())])).iterator());
 for (;;){
-JaktInternal::Optional<parser::IncludeAction> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::IncludeAction action = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>>>>{
-auto&& __jakt_match_variant = action;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::IncludeAction::Define>();DeprecatedString const& name = __jakt_match_value.name;
-DeprecatedString const& value = __jakt_match_value.value;
-{
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#ifdef {}\n"sv),name))));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#undef {}\n"sv),name))));
-(output += Jakt::DeprecatedString("#endif\n"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#define {} {}\n"sv),name,value))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::IncludeAction::Undefine>();DeprecatedString const& name = __jakt_match_value.name;
+types::TypeId type_id = (_magic_value.value());
 {
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#ifdef {}\n"sv),name))));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#undef {}\n"sv),name))));
-(output += Jakt::DeprecatedString("#endif\n"sv));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-}
-
-}
-}
-
-if (has_name){
-(output += ((Jakt::DeprecatedString(" } // namespace "sv) + (((scope)->namespace_name).value())) + Jakt::DeprecatedString("\n"sv)));
+if (first){
+(first = false);
 }
+else {
+(output += Jakt::DeprecatedString(", "sv));
 }
+
+(output += TRY((((*this).codegen_type(type_id)))));
 }
 
 }
 }
 
+(output += Jakt::DeprecatedString(">("sv));
+(first = true);
 {
-JaktInternal::ArrayIterator<types::ModuleId> _magic = ((((module)->imports)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
-JaktInternal::Optional<types::ModuleId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ModuleId id = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
-NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[((id).id)]);
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#include \"{}.h\"\n"sv),((module)->name)))));
+NonnullRefPtr<types::CheckedVariable> const variable = ((param).variable);
+if ((((variable)->name) == Jakt::DeprecatedString("this"sv))){
+continue;
 }
-
+if ((!(first))){
+(output += Jakt::DeprecatedString(","sv));
 }
+else {
+(first = false);
 }
 
+NonnullRefPtr<typename types::Type> const variable_type = ((((*this).program))->get_type(((variable)->type_id)));
+(output += TRY((((*this).codegen_type(((variable)->type_id))))));
+(output += Jakt::DeprecatedString(" "sv));
+if (((!(((variable)->is_mutable))) && (!((((variable_type)->index() == 27 /* Reference */) || ((variable_type)->index() == 28 /* MutableReference */)))))){
+(output += Jakt::DeprecatedString("const "sv));
 }
-(output += Jakt::DeprecatedString("namespace Jakt {\n"sv));
-if ((!(((module)->is_root)))){
-TRY((((((generator).namespace_stack)).push(((module)->name)))));
-}
-(output += TRY((((generator).codegen_namespace(scope,module,as_forward)))));
-if ((!(((module)->is_root)))){
-JaktInternal::Optional<DeprecatedString> const dummy = ((((generator).namespace_stack)).pop());
+(output += ((variable)->name));
 }
-(output += ((generator).deferred_output));
-(((generator).deferred_output) = Jakt::DeprecatedString(""sv));
-(output += Jakt::DeprecatedString("} // namespace Jakt\n"sv));
-if (as_forward){
-TRY((((result).set(header_name,(Tuple{output, ((module)->resolved_import_path)})))));
+
 }
-else {
-TRY((((result).set(impl_name,(Tuple{output, ((module)->resolved_import_path)})))));
 }
 
+(output += Jakt::DeprecatedString(")"sv));
+if (((!(((function)->is_static()))) && (!(((function)->is_mutating()))))){
+(output += Jakt::DeprecatedString(" const"sv));
 }
-
+(output += Jakt::DeprecatedString(";\n"sv));
 }
+else {
+(output = TRY((__jakt_format(Jakt::DeprecatedString("\n/* specialisation {} of function {} omitted, not fully specialized: {} */\n"sv),(((function)->specialization_index).value()),((function)->name),((((((function)->generics))->specializations))[(((function)->specialization_index).value())])))));
 }
 
+return (output);
+}
 }
 
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_destructor_predecl(types::CheckedStruct const& struct_) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += Jakt::DeprecatedString("public:\n"sv));
+(output += ((Jakt::DeprecatedString("    ~"sv) + ((((struct_))).name_for_codegen())) + Jakt::DeprecatedString("();\n"sv)));
+return (output);
 }
 }
 
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> codegen::CodeGenerator::extract_dependencies_from(types::TypeId const type_id,JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph,bool const top_level) const {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(((sorted_modules).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
+JaktInternal::DynamicArray<DeprecatedString> dependencies = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+NonnullRefPtr<typename types::Type> const type_ = ((((*this).program))->get_type(type_id));
+if (((!(((type_)->is_boxed(((*this).program))))) && ((dependency_graph).contains(TRY((((type_id).to_string()))))))){
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = (((((dependency_graph).get(TRY((((type_id).to_string()))))).value())).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t idx = (_magic_value.value());
+DeprecatedString dependency = (_magic_value.value());
 {
-size_t const i = ((((sorted_modules)[(JaktInternal::checked_sub<size_t>(idx,static_cast<size_t>(1ULL)))])).id);
-NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[i]);
-DeprecatedString const header_name = TRY((__jakt_format(Jakt::DeprecatedString("{}.h"sv),((module)->name))));
-DeprecatedString const impl_name = TRY((__jakt_format(Jakt::DeprecatedString("{}_specializations.cpp"sv),((module)->name))));
-if ((i == static_cast<size_t>(0ULL))){
-(output = Jakt::DeprecatedString(""sv));
+TRY((((dependencies).push(dependency))));
+}
+
 }
-else {
-(output = TRY((__jakt_format(Jakt::DeprecatedString("#include \"{}\"\n"sv),header_name))));
 }
 
+return (dependencies);
+}
+JaktInternal::DynamicArray<DeprecatedString> const inner_dependencies = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<DeprecatedString>, ErrorOr<JaktInternal::DynamicArray<DeprecatedString>>>{
+auto&& __jakt_match_variant = *type_;
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).extract_dependencies_from_enum(enum_id,dependency_graph,top_level)))));
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue(TRY((((*this).extract_dependencies_from_enum(id,dependency_graph,top_level)))));
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).extract_dependencies_from_struct(id,dependency_graph,top_level,(TRY((DynamicArray<types::TypeId>::create_with({})))))))));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(TRY((((*this).extract_dependencies_from_struct(id,dependency_graph,top_level,args)))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue((TRY((DynamicArray<DeprecatedString>::create_with({})))));
+};/*case end*/
+}/*switch end*/
+}()
+));
 {
-JaktInternal::ArrayIterator<types::ModuleId> _magic = ((sorted_modules).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((inner_dependencies).iterator());
 for (;;){
-JaktInternal::Optional<types::ModuleId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ModuleId id = (_magic_value.value());
+DeprecatedString dependency = (_magic_value.value());
 {
-if ((((id).id) == static_cast<size_t>(0ULL))){
-continue;
+TRY((((dependencies).push(dependency))));
+}
+
 }
-NonnullRefPtr<types::Module> const module = ((((((generator).program))->modules))[((id).id)]);
-(output += TRY((__jakt_format(Jakt::DeprecatedString("#include \"{}.h\"\n"sv),((module)->name)))));
 }
 
+return (dependencies);
 }
 }
 
-types::ScopeId const scope_id = types::ScopeId(((module)->id),static_cast<size_t>(0ULL));
-NonnullRefPtr<types::Scope> const scope = TRY((((((generator).program))->get_scope(scope_id))));
-(output += Jakt::DeprecatedString("namespace Jakt {\n"sv));
-if ((!(((module)->is_root)))){
-TRY((((((generator).namespace_stack)).push(((module)->name)))));
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_namespace(NonnullRefPtr<types::Scope> const scope,NonnullRefPtr<types::Module> const current_module,bool const as_forward) {
+{
+if ((((((scope)->alias_path)).has_value()) || ((((scope)->import_path_if_extern)).has_value()))){
+return (Jakt::DeprecatedString(""sv));
 }
-(output += TRY((((generator).codegen_namespace_specializations(scope,module)))));
-if ((!(((module)->is_root)))){
-JaktInternal::Optional<DeprecatedString> const dummy = ((((generator).namespace_stack)).pop());
+JaktInternal::Set<DeprecatedString> seen_types = (TRY((Set<DeprecatedString>::create_with_values({}))));
+if (as_forward){
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((((scope)->namespace_name)).has_value())){
+(output += ((Jakt::DeprecatedString("namespace "sv) + (((scope)->namespace_name).value())) + Jakt::DeprecatedString(" {\n"sv)));
 }
-(output += ((generator).deferred_output));
-(((generator).deferred_output) = Jakt::DeprecatedString(""sv));
-(output += Jakt::DeprecatedString("} // namespace Jakt\n"sv));
-TRY((((result).set(impl_name,(Tuple{output, ((module)->resolved_import_path)})))));
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const encoded_dependency_graph = TRY((((*this).produce_codegen_dependency_graph(scope))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> _magic = ((encoded_dependency_graph).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> entry = (_magic_value.value());
+{
+JaktInternal::DynamicArray<types::TypeId> const traversal = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((*this).postorder_traversal(((entry).template get<0>()),seen_types,encoded_dependency_graph,traversal))));
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((traversal).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+types::TypeId type_id = (_magic_value.value());
+{
+NonnullRefPtr<typename types::Type> const type_ = ((((*this).program))->get_type(type_id));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *type_;
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+{
+if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
+return JaktInternal::LoopContinue{};
 }
-
-return (result);
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+DeprecatedString const enum_output = TRY((((*this).codegen_enum(enum_))));
+if ((!(((enum_output).is_empty())))){
+(output += enum_output);
 }
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_call(types::CheckedCall const call) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
 {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((((((call).function_id)).has_value()) && ((((((*this).program))->get_function((((call).function_id).value()))))->is_comptime))){
-return (TRY((__jakt_format(Jakt::DeprecatedString("fail_comptime_call<{}, \"Comptime function {} called outside Jakt compiler\">()"sv),TRY((((*this).codegen_type(((call).return_type))))),((call).name)))));
+if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
+return JaktInternal::LoopContinue{};
 }
-if (((call).callee_throws)){
-(output += TRY((((*this).current_error_handler()))));
-(output += Jakt::DeprecatedString("(("sv));
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+DeprecatedString const struct_output = TRY((((*this).codegen_struct(struct_))));
+if ((!(((struct_output).is_empty())))){
+(output += struct_output);
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((call).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 26: {
 {
-DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((call).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected type in dependency graph: {}"sv),type_))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+TRY((((seen_types).add(TRY((((type_id).to_string())))))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
 }
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+
 }
-}()))
-;
-(output += helper);
-(output += Jakt::DeprecatedString("("sv));
+
+}
+}
+
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
+JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((scope)->structs)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::StructId> ___struct_id__ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
-DeprecatedString const _ = ((__expr_).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
+JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt_____struct_id__ = ___struct_id__;
+DeprecatedString const _ = ((jakt_____struct_id__).template get<0>());
+types::StructId const struct_id = ((jakt_____struct_id__).template get<1>());
 
-(output += TRY((((*this).codegen_expression(expr)))));
-if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
-(output += Jakt::DeprecatedString(","sv));
-}
+if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
+continue;
 }
-
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+if (((seen_types).contains(TRY((((((struct_).type_id)).to_string())))))){
+continue;
 }
+(output += TRY((((*this).codegen_struct(struct_)))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
 
-(output += Jakt::DeprecatedString(")"sv));
 }
-return JaktInternal::ExplicitValue<void>();
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+
 {
-DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((call).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
+JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((scope)->enums)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
+JaktInternal::Tuple<DeprecatedString,types::EnumId> ___enum_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt_____enum_id__ = ___enum_id__;
+DeprecatedString const _ = ((jakt_____enum_id__).template get<0>());
+types::EnumId const enum_id = ((jakt_____enum_id__).template get<1>());
+
+if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
+continue;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+if (((seen_types).contains(TRY((((((enum_).type_id)).to_string())))))){
+continue;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
+(output += TRY((((*this).codegen_enum(enum_)))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
+
 }
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
-}()))
-;
-(output += helper);
-(output += Jakt::DeprecatedString("("sv));
+
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
-DeprecatedString const _ = ((__expr_).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
-(output += TRY((((*this).codegen_expression(expr)))));
-if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
-(output += Jakt::DeprecatedString(","sv));
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+types::FunctionId function_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+if ((!(((((((function)->function_scope_id)).module_id)).equals(((current_module)->id)))))){
+continue;
 }
-
+if (((function)->is_comptime)){
+continue;
 }
+JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
+(((*this).current_function) = function);
+ScopeGuard __jakt_var_590([&] {
+(((*this).current_function) = previous_function);
+});
+if ((((((((function)->linkage)).index() == 1 /* External */) || ((((function)->type)).index() == 2 /* ImplicitConstructor */)) || ((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)) || ((((function)->type)).index() == 1 /* Destructor */))){
+continue;
 }
-
-(output += Jakt::DeprecatedString(")"sv));
+if (((((((function)->generics))->params)).is_empty())){
+continue;
 }
-return JaktInternal::ExplicitValue<void>();
+if ((!(((((function)->specialization_index)).has_value())))){
+(output += TRY((((*this).codegen_function_predecl(function,false,true)))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-{
-DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((call).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
+
 }
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
-}()))
-;
-(output += helper);
-(output += Jakt::DeprecatedString("("sv));
+
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+types::ScopeId child_scope_id = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
-DeprecatedString const _ = ((__expr_).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
-
-(output += TRY((((*this).codegen_expression(expr)))));
-if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
-(output += Jakt::DeprecatedString(","sv));
+NonnullRefPtr<types::Scope> const child_scope = TRY((((((*this).program))->get_scope(child_scope_id))));
+if (((((child_scope)->namespace_name)).has_value())){
+DeprecatedString const name = (((child_scope)->namespace_name).value());
+TRY((((((*this).namespace_stack)).push(name))));
+(output += TRY((((*this).codegen_namespace(child_scope,current_module,as_forward)))));
+JaktInternal::Optional<DeprecatedString> const dummy = ((((*this).namespace_stack)).pop());
 }
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(")"sv));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
-{
-DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((call).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
+if (((((scope)->namespace_name)).has_value())){
+(output += Jakt::DeprecatedString("}\n"sv));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
+return (output);
 }
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((((scope)->namespace_name)).has_value())){
+(output += ((Jakt::DeprecatedString("namespace "sv) + (((scope)->namespace_name).value())) + Jakt::DeprecatedString(" {\n"sv)));
 }
-}()))
-;
-(output += helper);
-(output += Jakt::DeprecatedString("("sv));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
-DeprecatedString const _ = ((__expr_).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
-(output += TRY((((*this).codegen_expression(expr)))));
-if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
-(output += Jakt::DeprecatedString(","sv));
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::FunctionId function_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+if ((!(((((((function)->function_scope_id)).module_id)).equals(((current_module)->id)))))){
+continue;
 }
+if (((function)->is_comptime)){
+continue;
 }
-
+JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
+(((*this).current_function) = function);
+ScopeGuard __jakt_var_591([&] {
+(((*this).current_function) = previous_function);
+});
+if ((((((((function)->linkage)).index() == 1 /* External */) || ((((function)->type)).index() == 2 /* ImplicitConstructor */)) || ((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)) || ((((function)->type)).index() == 1 /* Destructor */))){
+continue;
+}
+if (((((((function)->generics))->params)).is_empty())){
+(output += TRY((((*this).codegen_function(function,false)))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
 }
 
-(output += Jakt::DeprecatedString(")"sv));
 }
-return JaktInternal::ExplicitValue<void>();
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
-{
-DeprecatedString const helper = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (((call).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("out"sv));
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("outln"sv));
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warn"sv));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("warnln"sv));
+
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((scope)->structs)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("__jakt_format"sv));
+JaktInternal::Tuple<DeprecatedString,types::StructId> ___struct_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt_____struct_id__ = ___struct_id__;
+DeprecatedString const _ = ((jakt_____struct_id__).template get<0>());
+types::StructId const struct_id = ((jakt_____struct_id__).template get<1>());
+
+if ((!(((((struct_id).module)).equals(((current_module)->id)))))){
+continue;
 }
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+if (((((struct_).definition_linkage)).index() == 1 /* External */)){
+continue;
 }
-}()))
-;
-(output += helper);
-(output += Jakt::DeprecatedString("("sv));
+if ((!(((((struct_).generic_parameters)).is_empty())))){
+continue;
+}
+(output += TRY((((*this).codegen_debug_description_getter(struct_,false)))));
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((struct_).scope_id)))));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).args)).size()))});
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> const __expr_ = ((((call).args))[i]);
-DeprecatedString const _ = ((__expr_).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const expr = ((__expr_).template get<1>());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
-(output += TRY((((*this).codegen_expression(expr)))));
-if ((i != (JaktInternal::checked_sub<size_t>(((((call).args)).size()),static_cast<size_t>(1ULL))))){
-(output += Jakt::DeprecatedString(","sv));
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::FunctionId function_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
+(((*this).current_function) = function);
+ScopeGuard __jakt_var_592([&] {
+(((*this).current_function) = previous_function);
+});
+if (((((function)->type)).index() == 2 /* ImplicitConstructor */)){
+(output += TRY((((*this).codegen_constructor(function,false)))));
+(output += Jakt::DeprecatedString("\n"sv));
+}
+else if (((((function)->type)).index() == 1 /* Destructor */)){
+(output += TRY((((*this).codegen_destructor(((struct_)),((function)),false)))));
+(output += Jakt::DeprecatedString("\n"sv));
+}
+else if (((!(((((function)->type)).index() == 3 /* ImplicitEnumConstructor */))) && ((!(((function)->is_comptime))) && ((((((function)->generics))->params)).is_empty())))){
+(output += TRY((((*this).codegen_function_in_namespace(function,((struct_).type_id),false,false,JaktInternal::OptionalNone())))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(")"sv));
 }
-return JaktInternal::ExplicitValue<void>();
+
 }
-else {
-{
-bool close_enum_type_wrapper = false;
-if (((((call).function_id)).has_value())){
-types::FunctionId const function_id = (((call).function_id).value());
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
-NonnullRefPtr<types::Module> const type_module = ((((*this).program))->get_module(((function_id).module)));
-if ((((((function)->type)).index() == 2 /* ImplicitConstructor */) || ((((function)->type)).index() == 4 /* ExternalClassConstructor */))){
-types::TypeId const type_id = ((call).return_type);
-NonnullRefPtr<typename types::Type> const type = ((((*this).program))->get_type(type_id));
-(output += TRY((((*this).codegen_namespace_path(call)))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *type;
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-{
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-if (((((struct_).record_type)).index() == 1 /* Class */)){
-(output += ((call).name_for_codegen()));
-(output += Jakt::DeprecatedString("::__jakt_create"sv));
 }
-else {
-(output += ((call).name_for_codegen()));
+
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-{
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(id));
-if (((((struct_).record_type)).index() == 1 /* Class */)){
-(output += TRY((((*this).codegen_namespace_qualifier(((struct_).scope_id),true,JaktInternal::OptionalNone())))));
-(output += ((struct_).name_for_codegen()));
-(output += Jakt::DeprecatedString("<"sv));
-bool first = true;
+}
+
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((scope)->enums)).iterator());
 for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId arg = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::EnumId> ___enum_id__ = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
-}
-else {
-(first = false);
-}
+JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt_____enum_id__ = ___enum_id__;
+DeprecatedString const _ = ((jakt_____enum_id__).template get<0>());
+types::EnumId const enum_id = ((jakt_____enum_id__).template get<1>());
 
-(output += TRY((((*this).codegen_type(arg)))));
+if ((!(((((enum_id).module)).equals(((current_module)->id)))))){
+continue;
 }
-
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+if (((((enum_).definition_linkage)).index() == 1 /* External */)){
+continue;
 }
+if ((!(((((enum_).generic_parameters)).is_empty())))){
+continue;
 }
-
-(output += Jakt::DeprecatedString(">::__jakt_create"sv));
+if (((((enum_).underlying_type_id)).equals(types::void_type_id()))){
+(output += TRY((((*this).codegen_enum_debug_description_getter(enum_,false)))));
 }
-else {
-(output += ((call).name_for_codegen()));
-(output += Jakt::DeprecatedString("<"sv));
-bool first = true;
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((enum_).scope_id)))));
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
 for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId arg = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(", "sv));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
+
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-(first = false);
+types::FunctionId function_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(function_id));
+JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> const previous_function = ((*this).current_function);
+(((*this).current_function) = function);
+ScopeGuard __jakt_var_593([&] {
+(((*this).current_function) = previous_function);
+});
+if (((!(((((function)->type)).index() == 2 /* ImplicitConstructor */))) && ((!(((((function)->type)).index() == 3 /* ImplicitEnumConstructor */))) && ((!(((((function)->type)).index() == 1 /* Destructor */))) && ((!(((function)->is_comptime))) && ((((((function)->generics))->params)).is_empty())))))){
+(output += TRY((((*this).codegen_function_in_namespace(function,((enum_).type_id),false,false,JaktInternal::OptionalNone())))));
+(output += Jakt::DeprecatedString("\n"sv));
 }
-
-(output += TRY((((*this).codegen_type(arg)))));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(">"sv));
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-utility::panic(Jakt::DeprecatedString("Should be unreachable"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+
 }
-else if (((((function)->type)).index() == 3 /* ImplicitEnumConstructor */)){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(((function)->return_type_id)));
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-{
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-NonnullRefPtr<types::Module> const enum_type_module = ((((*this).program))->get_module(((enum_id).module)));
-if (((enum_).is_boxed)){
-(output += TRY((((*this).codegen_namespace_path(call)))));
-(output += Jakt::DeprecatedString("template __jakt_create<typename "sv));
-(output += TRY((((*this).codegen_type_possibly_as_namespace(((call).return_type),true)))));
-(output += ((Jakt::DeprecatedString("::"sv) + ((call).name_for_codegen())) + Jakt::DeprecatedString(">"sv)));
+
 }
-else {
-(output += (Jakt::DeprecatedString(" "sv) + TRY((((*this).codegen_type(((call).return_type)))))));
-(output += Jakt::DeprecatedString(" { "sv));
-(output += Jakt::DeprecatedString("typename "sv));
-(output += TRY((((*this).codegen_type_possibly_as_namespace(((call).return_type),true)))));
-(output += Jakt::DeprecatedString("::"sv));
-(output += ((call).name_for_codegen()));
-(close_enum_type_wrapper = true);
 }
 
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
 {
-utility::todo(Jakt::DeprecatedString("codegen generic enum instance"sv));
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
+for (;;){
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+types::ScopeId child_scope_id = (_magic_value.value());
 {
-utility::panic(Jakt::DeprecatedString("constructor expected enum type"sv));
+NonnullRefPtr<types::Scope> const child_scope = TRY((((((*this).program))->get_scope(child_scope_id))));
+if (((((child_scope)->namespace_name)).has_value())){
+DeprecatedString const name = (((child_scope)->namespace_name).value());
+TRY((((((*this).namespace_stack)).push(name))));
+(output += TRY((((*this).codegen_namespace(child_scope,current_module,as_forward)))));
+JaktInternal::Optional<DeprecatedString> const dummy = ((((*this).namespace_stack)).pop());
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
 }
-else {
-(output += TRY((((*this).codegen_namespace_path(call)))));
-(output += ((call).name_for_codegen()));
+
+}
 }
 
+if (((((scope)->namespace_name)).has_value())){
+(output += Jakt::DeprecatedString("}\n"sv));
+}
+return (output);
 }
-else {
-(output += TRY((((*this).codegen_namespace_path(call)))));
-(output += ((call).name_for_codegen()));
 }
 
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = ((call).type_args);
-if ((!(((generic_parameters).is_empty())))){
-JaktInternal::DynamicArray<DeprecatedString> types = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_unchecked_binary_op_assignment(NonnullRefPtr<typename types::CheckedExpression> const lhs,NonnullRefPtr<typename types::CheckedExpression> const rhs,parser::BinaryOperator const op,types::TypeId const type_id) {
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((generic_parameters).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::TypeId gen_param = (_magic_value.value());
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+(output += Jakt::DeprecatedString("{"sv));
+(output += Jakt::DeprecatedString("auto& _jakt_ref = "sv));
+(output += TRY((((*this).codegen_expression(lhs)))));
+(output += Jakt::DeprecatedString(";"sv));
+(output += Jakt::DeprecatedString("_jakt_ref = static_cast<"sv));
+(output += TRY((((*this).codegen_type(type_id)))));
+(output += Jakt::DeprecatedString(">(_jakt_ref "sv));
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 27: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" + "sv));
+};/*case end*/
+case 28: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" - "sv));
+};/*case end*/
+case 29: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" * "sv));
+};/*case end*/
+case 31: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" / "sv));
+};/*case end*/
+case 30: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(" % "sv));
+};/*case end*/
+default: {
 {
-TRY((((types).push(TRY((((*this).codegen_type_possibly_as_namespace(gen_param,false))))))));
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Checked binary operation assignment codegen is not supported for BinaryOperator::{}"sv),op))));
 }
-
+};/*case end*/
+}/*switch end*/
+}()
+)));
+(output += TRY((((*this).codegen_expression(rhs)))));
+(output += Jakt::DeprecatedString(");"sv));
+(output += Jakt::DeprecatedString("}"sv));
+return (output);
 }
 }
 
-(output += TRY((__jakt_format(Jakt::DeprecatedString("<{}>"sv),utility::join(types,Jakt::DeprecatedString(", "sv))))));
-}
-JaktInternal::DynamicArray<DeprecatedString> arguments = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_constructor(NonnullRefPtr<types::CheckedFunction> const function,bool const is_inline) {
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
+types::TypeId const type_id = ((function)->return_type_id);
+NonnullRefPtr<typename types::Type> const type_ = ((((*this).program))->get_type(type_id));
+if (((type_)->index() == 23 /* Struct */)){
+types::StructId const struct_id = ((type_)->get<types::Type::Struct>()).value;
+types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
+DeprecatedString const qualified_name = TRY((((*this).codegen_type_possibly_as_namespace(type_id,true))));
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if (((!(is_inline)) && (!(((((structure).generic_parameters)).is_empty()))))){
+(output += Jakt::DeprecatedString("template <"sv));
+bool first = true;
+{
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((structure).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
+types::CheckedGenericParameter param = (_magic_value.value());
 {
-TRY((((arguments).push(TRY((((*this).codegen_expression(((arg).template get<1>())))))))));
-}
-
+if (first){
+(first = false);
 }
+else {
+(output += Jakt::DeprecatedString(","sv));
 }
 
-(output += TRY((__jakt_format(Jakt::DeprecatedString("({})"sv),utility::join(arguments,Jakt::DeprecatedString(","sv))))));
-if (close_enum_type_wrapper){
-(output += Jakt::DeprecatedString(" } "sv));
-}
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-if (((call).callee_throws)){
-(output += Jakt::DeprecatedString("))"sv));
+(output += Jakt::DeprecatedString("typename "sv));
+(output += TRY((((*this).codegen_type(((param).type_id))))));
 }
-return (output);
+
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_generic_enum_instance(types::EnumId const id,JaktInternal::DynamicArray<types::TypeId> const args,bool const as_namespace) const {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-bool close_tag = false;
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(id));
-if (((!(as_namespace)) && ((enum_).is_boxed))){
-(output += Jakt::DeprecatedString("NonnullRefPtr<"sv));
-DeprecatedString const qualifier = TRY((((*this).codegen_namespace_qualifier(((enum_).scope_id),true,JaktInternal::OptionalNone()))));
-if ((!(((qualifier).is_empty())))){
-(output += Jakt::DeprecatedString("typename "sv));
-(output += qualifier);
+(output += Jakt::DeprecatedString(">\n"sv));
 }
-(output += ((enum_).name));
-(close_tag = true);
+if (((((structure).record_type)).index() == 1 /* Class */)){
+if (is_inline){
+(output += ((function)->name_for_codegen()));
+(output += Jakt::DeprecatedString("("sv));
 }
 else {
-DeprecatedString const qualifier = TRY((((*this).codegen_namespace_qualifier(((enum_).scope_id),true,JaktInternal::OptionalNone()))));
-if ((!(((qualifier).is_empty())))){
-if ((!(as_namespace))){
-(output += Jakt::DeprecatedString("typename "sv));
-}
-(output += qualifier);
-}
-(output += ((enum_).name));
+(output += TRY((__jakt_format(Jakt::DeprecatedString("{}::{}("sv),qualified_name,((function)->name_for_codegen())))));
 }
 
-(output += Jakt::DeprecatedString("<"sv));
 bool first = true;
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::TypeId type_id = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
 if ((!(first))){
 (output += Jakt::DeprecatedString(", "sv));
@@ -7196,106 +7075,108 @@ else {
 (first = false);
 }
 
-(output += TRY((((*this).codegen_type(type_id)))));
-}
-
-}
+types::TypeId const param_type_id = ((((param).variable))->type_id);
+(output += TRY((((*this).codegen_type(param_type_id)))));
+(output += Jakt::DeprecatedString(" a_"sv));
+(output += ((((param).variable))->name));
 }
 
-(output += Jakt::DeprecatedString(">"sv));
-if (close_tag){
-(output += Jakt::DeprecatedString(">"sv));
-}
-return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_function_generic_parameters(NonnullRefPtr<types::CheckedFunction> const function) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-if ((!(((((((function)->generics))->params)).is_empty())))){
-(output += Jakt::DeprecatedString("template <"sv));
-bool first = true;
+(output += Jakt::DeprecatedString(")"sv));
+if ((!(((((function)->params)).is_empty())))){
+(output += Jakt::DeprecatedString(": "sv));
+JaktInternal::DynamicArray<DeprecatedString> initializers = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+size_t const parent_constructor_parameter_count = (JaktInternal::checked_sub<size_t>(((((function)->params)).size()),((((structure).fields)).size())));
+if ((parent_constructor_parameter_count > static_cast<size_t>(0ULL))){
+DeprecatedString parent_initializer = Jakt::DeprecatedString(""sv);
+(parent_initializer += ((((((*this).program))->get_struct((((structure).super_struct_id).value())))).name_for_codegen()));
+(parent_initializer += Jakt::DeprecatedString("("sv));
+JaktInternal::DynamicArray<DeprecatedString> strings = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::FunctionGenericParameter> _magic = ((((((function)->generics))->params)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((((function)->params))[(JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(parent_constructor_parameter_count)})])).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionGenericParameter generic_parameter = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
-if (first){
-(first = false);
-}
-else {
-(output += Jakt::DeprecatedString(","sv));
+TRY((((strings).push(((Jakt::DeprecatedString("move(a_"sv) + ((((param).variable))->name)) + Jakt::DeprecatedString(")"sv))))));
 }
 
-(output += Jakt::DeprecatedString("typename "sv));
-(output += TRY((((*this).codegen_type(((generic_parameter).type_id()))))));
+}
 }
 
+(parent_initializer += utility::join(strings,Jakt::DeprecatedString(", "sv)));
+(parent_initializer += Jakt::DeprecatedString(")"sv));
+TRY((((initializers).push(parent_initializer))));
+}
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(parent_constructor_parameter_count),static_cast<size_t>(((((function)->params)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+size_t i = (_magic_value.value());
+{
+types::CheckedParameter const param = ((((function)->params))[i]);
+TRY((((initializers).push((((((((param).variable))->name) + Jakt::DeprecatedString("(move(a_"sv)) + ((((param).variable))->name)) + Jakt::DeprecatedString("))"sv))))));
 }
 
-(output += Jakt::DeprecatedString(">\n"sv));
-}
-return (output);
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_ak_formatter(DeprecatedString const name,JaktInternal::DynamicArray<DeprecatedString> const generic_parameter_names) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-DeprecatedString const template_args = utility::join(TRY((utility::prepend_to_each(generic_parameter_names,Jakt::DeprecatedString("typename "sv)))),Jakt::DeprecatedString(", "sv));
-DeprecatedString const generic_type_args = utility::join(generic_parameter_names,Jakt::DeprecatedString(", "sv));
-DeprecatedString qualified_name = Jakt::DeprecatedString(""sv);
+(output += utility::join(initializers,Jakt::DeprecatedString(", "sv)));
+}
+(output += Jakt::DeprecatedString("{}\n"sv));
+DeprecatedString class_name_with_generics = Jakt::DeprecatedString(""sv);
+(class_name_with_generics += ((structure).name_for_codegen()));
+(first = true);
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((*this).namespace_stack)).iterator());
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((structure).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString namespace_ = (_magic_value.value());
+types::CheckedGenericParameter generic_parameter = (_magic_value.value());
 {
-(qualified_name += TRY((__jakt_format(Jakt::DeprecatedString("{}::"sv),namespace_))));
+if ((!(first))){
+(class_name_with_generics += Jakt::DeprecatedString(", "sv));
+}
+else {
+(class_name_with_generics += Jakt::DeprecatedString("<"sv));
+(first = false);
+}
+
+(class_name_with_generics += TRY((((*this).codegen_type(((generic_parameter).type_id))))));
 }
 
 }
 }
 
-(qualified_name += name);
-if ((!(((generic_parameter_names).is_empty())))){
-(qualified_name += TRY((__jakt_format(Jakt::DeprecatedString("<{}>\n"sv),generic_type_args))));
+if ((!(((((structure).generic_parameters)).is_empty())))){
+(class_name_with_generics += Jakt::DeprecatedString(">"sv));
 }
-(output += Jakt::DeprecatedString("} // namespace Jakt\n"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("template<{}>"sv),template_args))));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("struct Jakt::Formatter<Jakt::{}> : Jakt::Formatter<Jakt::StringView>"sv),qualified_name))));
-(output += Jakt::DeprecatedString("{\n"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::{} const& value) {{\n"sv),qualified_name))));
-(output += Jakt::DeprecatedString("JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };"sv));
-(output += Jakt::DeprecatedString("Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));"sv));
-(output += Jakt::DeprecatedString("return format_error;"sv));
-(output += Jakt::DeprecatedString("}\n"sv));
-(output += Jakt::DeprecatedString("};\n"sv));
-return ((output + Jakt::DeprecatedString("namespace Jakt {\n"sv)));
+if (is_inline){
+(output += Jakt::DeprecatedString("static "sv));
 }
+DeprecatedString const qualified_namespace = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (is_inline);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
-
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_constructor_predecl(NonnullRefPtr<types::CheckedFunction> const function) {
-{
-types::TypeId const type_id = ((function)->return_type_id);
-NonnullRefPtr<typename types::Type> const type_ = ((((*this).program))->get_type(type_id));
-if (((type_)->index() == 23 /* Struct */)){
-types::StructId const struct_id = ((type_)->get<types::Type::Struct>()).value;
-types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
-if (((((structure).record_type)).index() == 1 /* Class */)){
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += Jakt::DeprecatedString("protected:\n"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("explicit {}("sv),((function)->name_for_codegen())))));
-bool first = true;
+else {
+return JaktInternal::ExplicitValue((qualified_name + Jakt::DeprecatedString("::"sv)));
+}
+}()))
+;
+(output += TRY((__jakt_format(Jakt::DeprecatedString("ErrorOr<NonnullRefPtr<{}>> {}__jakt_create"sv),class_name_with_generics,qualified_namespace))));
+(output += Jakt::DeprecatedString("("sv));
+(first = true);
 {
 JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
@@ -7312,49 +7193,50 @@ else {
 (first = false);
 }
 
-types::TypeId const param_type_id = ((((param).variable))->type_id);
-(output += TRY((((*this).codegen_type(param_type_id)))));
-(output += Jakt::DeprecatedString(" a_"sv));
+(output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
+(output += Jakt::DeprecatedString(" "sv));
 (output += ((((param).variable))->name));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(");\n"sv));
-DeprecatedString class_name_with_generics = Jakt::DeprecatedString(""sv);
-(class_name_with_generics += ((structure).name_for_codegen()));
+(output += TRY((__jakt_format(Jakt::DeprecatedString(") {{ auto o = {}(adopt_nonnull_ref_or_enomem(new (nothrow) {} ("sv),TRY((((*this).current_error_handler()))),class_name_with_generics))));
 (first = true);
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((structure).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter generic_parameter = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
 if ((!(first))){
-(class_name_with_generics += Jakt::DeprecatedString(", "sv));
+(output += Jakt::DeprecatedString(", "sv));
 }
 else {
-(class_name_with_generics += Jakt::DeprecatedString("<"sv));
 (first = false);
 }
 
-(class_name_with_generics += TRY((((*this).codegen_type(((generic_parameter).type_id))))));
+(output += Jakt::DeprecatedString("move("sv));
+(output += ((((param).variable))->name));
+(output += Jakt::DeprecatedString(")"sv));
 }
 
 }
 }
 
-if ((!(((((structure).generic_parameters)).is_empty())))){
-(class_name_with_generics += Jakt::DeprecatedString(">"sv));
+(output += Jakt::DeprecatedString("))); return o; }"sv));
+return (output);
 }
-(output += Jakt::DeprecatedString("public:\n"sv));
-(output += TRY((__jakt_format(Jakt::DeprecatedString("static ErrorOr<NonnullRefPtr<{}>> __jakt_create"sv),class_name_with_generics))));
+if ((!(is_inline))){
+(output += qualified_name);
+(output += Jakt::DeprecatedString("::"sv));
+}
+(output += ((function)->name_for_codegen()));
 (output += Jakt::DeprecatedString("("sv));
-(first = true);
+bool first = true;
 {
 JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
@@ -7372,20 +7254,18 @@ else {
 }
 
 (output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
-(output += Jakt::DeprecatedString(" "sv));
+(output += Jakt::DeprecatedString(" a_"sv));
 (output += ((((param).variable))->name));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(");\n"sv));
-return (output);
+(output += Jakt::DeprecatedString(") "sv));
+if ((!(((((function)->params)).is_empty())))){
+(output += Jakt::DeprecatedString(":"sv));
 }
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-(output += ((function)->name_for_codegen()));
-(output += Jakt::DeprecatedString("("sv));
-bool first = true;
+(first = true);
 {
 JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((function)->params)).iterator());
 for (;;){
@@ -7402,15 +7282,16 @@ else {
 (first = false);
 }
 
-(output += TRY((((*this).codegen_type(((((param).variable))->type_id))))));
-(output += Jakt::DeprecatedString(" a_"sv));
 (output += ((((param).variable))->name));
+(output += Jakt::DeprecatedString("(move(a_"sv));
+(output += ((((param).variable))->name));
+(output += Jakt::DeprecatedString("))"sv));
 }
 
 }
 }
 
-(output += Jakt::DeprecatedString(");\n"sv));
+(output += Jakt::DeprecatedString("{}\n"sv));
 return (output);
 }
 else {
@@ -7420,103 +7301,222 @@ utility::panic(Jakt::DeprecatedString("internal error: call to a constructor, bu
 }
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_type(types::TypeId const type_id) const {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_type_possibly_as_namespace(types::TypeId const type_id,bool const as_namespace) const {
 {
-return (TRY((((*this).codegen_type_possibly_as_namespace(type_id,false)))));
-}
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("void"sv));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("bool"sv));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u8"sv));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u16"sv));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u32"sv));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u64"sv));
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i8"sv));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i16"sv));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i32"sv));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i64"sv));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("f32"sv));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("f64"sv));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("size_t"sv));
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("DeprecatedString"sv));
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("char"sv));
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("int"sv));
+};/*case end*/
+case 17: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("void"sv));
+};/*case end*/
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((TRY((((*this).codegen_type(type_id)))) + Jakt::DeprecatedString("*"sv)));
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((TRY((((*this).codegen_type(type_id)))) + Jakt::DeprecatedString(" const&"sv)));
+};/*case end*/
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((TRY((((*this).codegen_type(type_id)))) + Jakt::DeprecatedString("&"sv)));
+};/*case end*/
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericResolvedType>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_generic_type_instance(id,args,as_namespace)))));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_generic_type_instance(id,args,as_namespace)))));
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_struct_type(id,as_namespace)))));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_enum_type(id,as_namespace)))));
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(TRY((((*this).codegen_generic_enum_instance(id,args,as_namespace)))));
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::TypeVariable>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(name);
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
+bool const& can_throw = __jakt_match_value.can_throw;
+types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_594; {
+DeprecatedString output = Jakt::DeprecatedString("Function<"sv);
+if (can_throw){
+(output += Jakt::DeprecatedString("ErrorOr<"sv));
 }
-
-ErrorOr<void> codegen::CodeGenerator::postorder_traversal(DeprecatedString const encoded_type_id,JaktInternal::Set<DeprecatedString> visited,JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const encoded_dependency_graph,JaktInternal::DynamicArray<types::TypeId> output) const {
-{
-types::TypeId const type_id = TRY((types::TypeId::from_string(encoded_type_id)));
-if (((visited).contains(TRY((((type_id).to_string())))))){
-return {};
+(output += TRY((((*this).codegen_type(return_type_id)))));
+if (can_throw){
+(output += Jakt::DeprecatedString(">"sv));
 }
-TRY((((visited).add(TRY((((type_id).to_string())))))));
-if (((encoded_dependency_graph).contains(encoded_type_id))){
+(output += Jakt::DeprecatedString("("sv));
+bool first = true;
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = (((((encoded_dependency_graph).get(encoded_type_id)).value())).iterator());
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((params).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString dependency = (_magic_value.value());
+types::TypeId param = (_magic_value.value());
 {
-TRY((((*this).postorder_traversal(dependency,visited,encoded_dependency_graph,output))));
-}
-
+if (first){
+(first = false);
 }
+else {
+(output += Jakt::DeprecatedString(", "sv));
 }
 
-}
-TRY((((output).push(type_id))));
-}
-return {};
+(output += TRY((((*this).codegen_type(param)))));
 }
 
-ErrorOr<DeprecatedString> codegen::CodeGenerator::fresh_label() {
-{
-return (TRY((__jakt_format(Jakt::DeprecatedString("__jakt_label_{}"sv),((((*this).fresh_label_counter)++))))));
 }
 }
 
-ErrorOr<DeprecatedString> codegen::ControlFlowState::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ControlFlowState("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("allowed_exits: {}, ", allowed_exits));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("passes_through_match: {}, ", passes_through_match));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("passes_through_try: {}, ", passes_through_try));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("match_nest_level: {}", match_nest_level));
+(output += Jakt::DeprecatedString(")>"sv));
+__jakt_var_594 = output; goto __jakt_label_519;
+
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-codegen::ControlFlowState codegen::ControlFlowState::enter_function() const {
+__jakt_label_519:; __jakt_var_594.release_value(); }));
+};/*case end*/
+case 21: {
 {
-return (codegen::ControlFlowState( codegen::AllowedControlExits { typename codegen::AllowedControlExits::JustReturn() } ,false,false,((*this).match_nest_level)));
-}
+utility::panic(Jakt::DeprecatedString("Generic trait instance in codegen"sv));
 }
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_595; {
+__jakt_var_595 = Jakt::DeprecatedString("auto"sv); goto __jakt_label_520;
 
-codegen::ControlFlowState codegen::ControlFlowState::enter_loop() const {
-{
-return (codegen::ControlFlowState( codegen::AllowedControlExits { typename codegen::AllowedControlExits::AtLoop() } ,false,((*this).passes_through_try),static_cast<size_t>(0ULL)));
+}
+__jakt_label_520:; __jakt_var_595.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
-codegen::ControlFlowState codegen::ControlFlowState::no_control_flow() {
+ErrorOr<DeprecatedString> codegen::CodeGenerator::codegen_struct_predecl(types::CheckedStruct const struct_) {
 {
-return (codegen::ControlFlowState( codegen::AllowedControlExits { typename codegen::AllowedControlExits::Nothing() } ,false,false,static_cast<size_t>(0ULL)));
+if (((((struct_).definition_linkage)).index() == 1 /* External */)){
+return (Jakt::DeprecatedString(""sv));
 }
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+if ((!(((((struct_).generic_parameters)).is_empty())))){
+(output += Jakt::DeprecatedString("template <"sv));
+bool first = true;
+{
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-bool codegen::ControlFlowState::is_match_nested() const {
+types::CheckedGenericParameter generic_parameter = (_magic_value.value());
 {
-return ((((*this).match_nest_level) != static_cast<size_t>(0ULL)));
+if (first){
+(first = false);
 }
+else {
+(output += Jakt::DeprecatedString(","sv));
 }
 
-DeprecatedString codegen::ControlFlowState::choose_control_flow_macro() const {
-{
-if (codegen::are_loop_exits_allowed(((*this).allowed_exits))){
-if (((*this).is_match_nested())){
-return (Jakt::DeprecatedString("JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH"sv));
-}
-return (Jakt::DeprecatedString("JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP"sv));
+(output += Jakt::DeprecatedString("typename "sv));
+(output += TRY((((*this).codegen_type(((generic_parameter).type_id))))));
 }
-return (Jakt::DeprecatedString("JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY"sv));
+
 }
 }
 
-codegen::ControlFlowState codegen::ControlFlowState::enter_match() const {
-{
-size_t level = ((*this).match_nest_level);
-if (((*this).passes_through_match)){
-(level = (JaktInternal::checked_add<size_t>(((*this).match_nest_level),static_cast<size_t>(1ULL))));
+(output += Jakt::DeprecatedString(">"sv));
 }
-return (codegen::ControlFlowState(((((*this).allowed_exits)).allow_return()),true,((*this).passes_through_try),level));
+(output += JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = ((struct_).record_type);
+switch(__jakt_match_variant.index()) {
+case 1: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("class "sv));
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("struct "sv));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+(output += ((struct_).name_for_codegen()));
+(output += Jakt::DeprecatedString(";"sv));
+return (output);
 }
 }
 
-codegen::ControlFlowState::ControlFlowState(codegen::AllowedControlExits a_allowed_exits, bool a_passes_through_match, bool a_passes_through_try, size_t a_match_nest_level) :allowed_exits(move(a_allowed_exits)), passes_through_match(move(a_passes_through_match)), passes_through_try(move(a_passes_through_try)), match_nest_level(move(a_match_nest_level)){}
-
 ErrorOr<DeprecatedString> codegen::AllowedControlExits::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
 switch (this->index()) {case 0 /* Nothing */: {
diff --git a/bootstrap/stage0/codegen.h b/bootstrap/stage0/codegen.h
index bad58f728..f44a2a5d4 100644
--- a/bootstrap/stage0/codegen.h
+++ b/bootstrap/stage0/codegen.h
@@ -40,71 +40,71 @@ NonnullRefPtr<compiler::Compiler> compiler;JaktInternal::Dictionary<size_t,JaktI
 ErrorOr<DeprecatedString> span_to_source_location(utility::Span const span);
 CodegenDebugInfo(NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::Dictionary<size_t,JaktInternal::DynamicArray<codegen::LineSpan>> a_line_spans, bool a_statement_span_comments);
 
-ErrorOr<DeprecatedString> debug_description() const;
-};struct LineSpan {
-  public:
-size_t start;size_t end;LineSpan(size_t a_start, size_t a_end);
-
 ErrorOr<DeprecatedString> debug_description() const;
 };struct CodeGenerator {
   public:
-NonnullRefPtr<compiler::Compiler> compiler;NonnullRefPtr<types::CheckedProgram> program;codegen::ControlFlowState control_flow_state;JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> entered_yieldable_blocks;DeprecatedString deferred_output;JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> current_function;bool inside_defer;codegen::CodegenDebugInfo debug_info;JaktInternal::DynamicArray<DeprecatedString> namespace_stack;size_t fresh_var_counter;size_t fresh_label_counter;ErrorOr<DeprecatedString> codegen_function(NonnullRefPtr<types::CheckedFunction> const function, bool const as_method);
-ErrorOr<DeprecatedString> codegen_generic_type_instance(types::StructId const id, JaktInternal::DynamicArray<types::TypeId> const args, bool const as_namespace) const;
-ErrorOr<JaktInternal::DynamicArray<types::ModuleId>> topologically_sort_modules() const;
-ErrorOr<DeprecatedString> codegen_debug_description_getter(types::CheckedStruct const struct_, bool const is_inline);
+NonnullRefPtr<compiler::Compiler> compiler;NonnullRefPtr<types::CheckedProgram> program;codegen::ControlFlowState control_flow_state;JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> entered_yieldable_blocks;DeprecatedString deferred_output;JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> current_function;bool inside_defer;codegen::CodegenDebugInfo debug_info;JaktInternal::DynamicArray<DeprecatedString> namespace_stack;size_t fresh_var_counter;size_t fresh_label_counter;static ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> generate(NonnullRefPtr<compiler::Compiler> const compiler, NonnullRefPtr<types::CheckedProgram> const program, bool const debug_info);
+ErrorOr<DeprecatedString> codegen_destructor(types::CheckedStruct const& struct_, NonnullRefPtr<types::CheckedFunction> const& function, bool const is_inline);
 ErrorOr<DeprecatedString> codegen_unchecked_binary_op(NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op, types::TypeId const type_id);
-ErrorOr<DeprecatedString> codegen_namespace(NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::Module> const current_module, bool const as_forward);
-ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>>> produce_codegen_dependency_graph(NonnullRefPtr<types::Scope> const scope) const;
-ErrorOr<DeprecatedString> codegen_unchecked_binary_op_assignment(NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op, types::TypeId const type_id);
-ErrorOr<JaktInternal::Optional<DeprecatedString>> codegen_namespace_specialization(types::FunctionId const function_id, JaktInternal::Optional<types::TypeId> const containing_struct, NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::Module> const current_module, bool const define_pass);
-ErrorOr<DeprecatedString> codegen_namespace_specializations(NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::Module> const current_module);
-ErrorOr<DeprecatedString> codegen_expression_and_deref_if_generic_and_needed(NonnullRefPtr<typename types::CheckedExpression> const expression);
-ErrorOr<DeprecatedString> codegen_enum(types::CheckedEnum const enum_);
-ErrorOr<DeprecatedString> codegen_struct_type(types::StructId const id, bool const as_namespace) const;
-ErrorOr<DeprecatedString> codegen_struct_predecl(types::CheckedStruct const struct_);
-ErrorOr<DeprecatedString> codegen_generic_match(NonnullRefPtr<typename types::CheckedExpression> const expr, JaktInternal::DynamicArray<types::CheckedMatchCase> const cases, types::TypeId const return_type_id, bool const all_variants_constant);
-ErrorOr<DeprecatedString> codegen_checked_binary_op(NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op, types::TypeId const type_id);
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> extract_dependencies_from_enum(types::EnumId const enum_id, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph, bool const top_level) const;
-ErrorOr<DeprecatedString> codegen_expression(NonnullRefPtr<typename types::CheckedExpression> const expression);
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> extract_dependencies_from_struct(types::StructId const struct_id, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph, bool const top_level, JaktInternal::DynamicArray<types::TypeId> const args) const;
-ErrorOr<DeprecatedString> codegen_function_in_namespace(NonnullRefPtr<types::CheckedFunction> const function, JaktInternal::Optional<types::TypeId> const containing_struct, bool const as_method, bool const skip_template, JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const explicit_generic_instantiation);
-ErrorOr<DeprecatedString> codegen_destructor_predecl(types::CheckedStruct const& struct_);
-ErrorOr<DeprecatedString> codegen_method_call(NonnullRefPtr<typename types::CheckedExpression> const expr, types::CheckedCall const call, bool const is_optional);
-CodeGenerator(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, codegen::ControlFlowState a_control_flow_state, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> a_entered_yieldable_blocks, DeprecatedString a_deferred_output, JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> a_current_function, bool a_inside_defer, codegen::CodegenDebugInfo a_debug_info, JaktInternal::DynamicArray<DeprecatedString> a_namespace_stack, size_t a_fresh_var_counter, size_t a_fresh_label_counter);
-
-ErrorOr<DeprecatedString> codegen_struct(types::CheckedStruct const struct_);
-ErrorOr<DeprecatedString> codegen_enum_predecl(types::CheckedEnum const enum_);
-ErrorOr<DeprecatedString> codegen_binary_expression(NonnullRefPtr<typename types::CheckedExpression> const expression, types::TypeId const type_id, NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op);
-ErrorOr<DeprecatedString> codegen_namespace_predecl(NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::Module> const current_module);
-ErrorOr<DeprecatedString> current_error_handler() const;
 ErrorOr<DeprecatedString> codegen_namespace_qualifier(types::ScopeId const scope_id, bool const skip_current, JaktInternal::Optional<DeprecatedString> const possible_constructor_name) const;
-ErrorOr<DeprecatedString> codegen_statement(NonnullRefPtr<typename types::CheckedStatement> const statement);
+ErrorOr<DeprecatedString> codegen_checked_binary_op(NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op, types::TypeId const type_id);
+ErrorOr<DeprecatedString> codegen_constructor_predecl(NonnullRefPtr<types::CheckedFunction> const function);
 bool is_full_respecialization(JaktInternal::DynamicArray<types::TypeId> const type_args) const;
-ErrorOr<DeprecatedString> codegen_namespace_path(types::CheckedCall const call) const;
-ErrorOr<DeprecatedString> codegen_type_possibly_as_namespace(types::TypeId const type_id, bool const as_namespace) const;
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> extract_dependencies_from(types::TypeId const type_id, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph, bool const top_level) const;
-ErrorOr<DeprecatedString> codegen_match_body(types::CheckedMatchBody const body, types::TypeId const return_type_id);
+ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>>> produce_codegen_dependency_graph(NonnullRefPtr<types::Scope> const scope) const;
+ErrorOr<DeprecatedString> codegen_statement(NonnullRefPtr<typename types::CheckedStatement> const statement);
+ErrorOr<DeprecatedString> codegen_function_generic_parameters(NonnullRefPtr<types::CheckedFunction> const function);
 ErrorOr<DeprecatedString> codegen_function_predecl(NonnullRefPtr<types::CheckedFunction> const function, bool const as_method, bool const allow_generics);
+ErrorOr<DeprecatedString> codegen_match_body(types::CheckedMatchBody const body, types::TypeId const return_type_id);
+ErrorOr<DeprecatedString> codegen_ak_formatter(DeprecatedString const name, JaktInternal::DynamicArray<DeprecatedString> const generic_parameter_names);
+ErrorOr<DeprecatedString> codegen_method_call(NonnullRefPtr<typename types::CheckedExpression> const expr, types::CheckedCall const call, bool const is_optional);
+ErrorOr<DeprecatedString> fresh_label();
 ErrorOr<DeprecatedString> fresh_var();
-ErrorOr<DeprecatedString> codegen_destructor(types::CheckedStruct const& struct_, NonnullRefPtr<types::CheckedFunction> const& function, bool const is_inline);
+ErrorOr<DeprecatedString> codegen_call(types::CheckedCall const call);
+ErrorOr<DeprecatedString> codegen_namespace_predecl(NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::Module> const current_module);
+ErrorOr<JaktInternal::DynamicArray<types::ModuleId>> topologically_sort_modules() const;
 ErrorOr<DeprecatedString> codegen_block(types::CheckedBlock const block);
-ErrorOr<DeprecatedString> codegen_checked_binary_op_assignment(NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op, types::TypeId const type_id);
+ErrorOr<DeprecatedString> codegen_generic_match(NonnullRefPtr<typename types::CheckedExpression> const expr, JaktInternal::DynamicArray<types::CheckedMatchCase> const cases, types::TypeId const return_type_id, bool const all_variants_constant);
+ErrorOr<DeprecatedString> codegen_debug_description_getter(types::CheckedStruct const struct_, bool const is_inline);
+ErrorOr<DeprecatedString> codegen_lambda_block(bool const can_throw, types::CheckedBlock const block, types::TypeId const return_type_id);
+ErrorOr<DeprecatedString> codegen_match(NonnullRefPtr<typename types::CheckedExpression> const expr, JaktInternal::DynamicArray<types::CheckedMatchCase> const match_cases, types::TypeId const type_id, bool const all_variants_constant);
+ErrorOr<DeprecatedString> codegen_namespace_specializations(NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::Module> const current_module);
 ErrorOr<DeprecatedString> codegen_enum_type(types::EnumId const id, bool const as_namespace) const;
-ErrorOr<DeprecatedString> codegen_constructor(NonnullRefPtr<types::CheckedFunction> const function, bool const is_inline);
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> extract_dependencies_from_struct(types::StructId const struct_id, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph, bool const top_level, JaktInternal::DynamicArray<types::TypeId> const args) const;
+ErrorOr<DeprecatedString> codegen_checked_binary_op_assignment(NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op, types::TypeId const type_id);
+ErrorOr<DeprecatedString> codegen_expression_and_deref_if_generic_and_needed(NonnullRefPtr<typename types::CheckedExpression> const expression);
+ErrorOr<DeprecatedString> codegen_struct(types::CheckedStruct const struct_);
+CodeGenerator(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, codegen::ControlFlowState a_control_flow_state, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> a_entered_yieldable_blocks, DeprecatedString a_deferred_output, JaktInternal::Optional<NonnullRefPtr<types::CheckedFunction>> a_current_function, bool a_inside_defer, codegen::CodegenDebugInfo a_debug_info, JaktInternal::DynamicArray<DeprecatedString> a_namespace_stack, size_t a_fresh_var_counter, size_t a_fresh_label_counter);
+
+ErrorOr<DeprecatedString> codegen_function(NonnullRefPtr<types::CheckedFunction> const function, bool const as_method);
+ErrorOr<DeprecatedString> codegen_generic_type_instance(types::StructId const id, JaktInternal::DynamicArray<types::TypeId> const args, bool const as_namespace) const;
 ErrorOr<DeprecatedString> codegen_enum_debug_description_getter(types::CheckedEnum const enum_, bool const is_inline);
+ErrorOr<DeprecatedString> codegen_expression(NonnullRefPtr<typename types::CheckedExpression> const expression);
+ErrorOr<DeprecatedString> codegen_binary_expression(NonnullRefPtr<typename types::CheckedExpression> const expression, types::TypeId const type_id, NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op);
+ErrorOr<DeprecatedString> current_error_handler() const;
 ErrorOr<DeprecatedString> codegen_enum_match(types::CheckedEnum const enum_, NonnullRefPtr<typename types::CheckedExpression> const expr, JaktInternal::DynamicArray<types::CheckedMatchCase> const match_cases, types::TypeId const type_id, bool const all_variants_constant);
-ErrorOr<DeprecatedString> codegen_lambda_block(bool const can_throw, types::CheckedBlock const block, types::TypeId const return_type_id);
-ErrorOr<DeprecatedString> codegen_match(NonnullRefPtr<typename types::CheckedExpression> const expr, JaktInternal::DynamicArray<types::CheckedMatchCase> const match_cases, types::TypeId const type_id, bool const all_variants_constant);
-ErrorOr<DeprecatedString> codegen_function_return_type(NonnullRefPtr<types::CheckedFunction> const function);
-static ErrorOr<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<DeprecatedString,DeprecatedString>>> generate(NonnullRefPtr<compiler::Compiler> const compiler, NonnullRefPtr<types::CheckedProgram> const program, bool const debug_info);
-ErrorOr<DeprecatedString> codegen_call(types::CheckedCall const call);
+ErrorOr<DeprecatedString> codegen_namespace_path(types::CheckedCall const call) const;
+ErrorOr<DeprecatedString> codegen_enum(types::CheckedEnum const enum_);
+ErrorOr<DeprecatedString> codegen_struct_type(types::StructId const id, bool const as_namespace) const;
+ErrorOr<DeprecatedString> codegen_enum_predecl(types::CheckedEnum const enum_);
+ErrorOr<void> postorder_traversal(DeprecatedString const encoded_type_id, JaktInternal::Set<DeprecatedString> visited, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const encoded_dependency_graph, JaktInternal::DynamicArray<types::TypeId> output) const;
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> extract_dependencies_from_enum(types::EnumId const enum_id, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph, bool const top_level) const;
 ErrorOr<DeprecatedString> codegen_generic_enum_instance(types::EnumId const id, JaktInternal::DynamicArray<types::TypeId> const args, bool const as_namespace) const;
-ErrorOr<DeprecatedString> codegen_function_generic_parameters(NonnullRefPtr<types::CheckedFunction> const function);
-ErrorOr<DeprecatedString> codegen_ak_formatter(DeprecatedString const name, JaktInternal::DynamicArray<DeprecatedString> const generic_parameter_names);
-ErrorOr<DeprecatedString> codegen_constructor_predecl(NonnullRefPtr<types::CheckedFunction> const function);
+ErrorOr<DeprecatedString> codegen_function_return_type(NonnullRefPtr<types::CheckedFunction> const function);
+ErrorOr<DeprecatedString> codegen_function_in_namespace(NonnullRefPtr<types::CheckedFunction> const function, JaktInternal::Optional<types::TypeId> const containing_struct, bool const as_method, bool const skip_template, JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const explicit_generic_instantiation);
 ErrorOr<DeprecatedString> codegen_type(types::TypeId const type_id) const;
-ErrorOr<void> postorder_traversal(DeprecatedString const encoded_type_id, JaktInternal::Set<DeprecatedString> visited, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const encoded_dependency_graph, JaktInternal::DynamicArray<types::TypeId> output) const;
-ErrorOr<DeprecatedString> fresh_label();
+ErrorOr<JaktInternal::Optional<DeprecatedString>> codegen_namespace_specialization(types::FunctionId const function_id, JaktInternal::Optional<types::TypeId> const containing_struct, NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::Module> const current_module, bool const define_pass);
+ErrorOr<DeprecatedString> codegen_destructor_predecl(types::CheckedStruct const& struct_);
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> extract_dependencies_from(types::TypeId const type_id, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<DeprecatedString>> const dependency_graph, bool const top_level) const;
+ErrorOr<DeprecatedString> codegen_namespace(NonnullRefPtr<types::Scope> const scope, NonnullRefPtr<types::Module> const current_module, bool const as_forward);
+ErrorOr<DeprecatedString> codegen_unchecked_binary_op_assignment(NonnullRefPtr<typename types::CheckedExpression> const lhs, NonnullRefPtr<typename types::CheckedExpression> const rhs, parser::BinaryOperator const op, types::TypeId const type_id);
+ErrorOr<DeprecatedString> codegen_constructor(NonnullRefPtr<types::CheckedFunction> const function, bool const is_inline);
+ErrorOr<DeprecatedString> codegen_type_possibly_as_namespace(types::TypeId const type_id, bool const as_namespace) const;
+ErrorOr<DeprecatedString> codegen_struct_predecl(types::CheckedStruct const struct_);
+ErrorOr<DeprecatedString> debug_description() const;
+};struct LineSpan {
+  public:
+size_t start;size_t end;LineSpan(size_t a_start, size_t a_end);
+
 ErrorOr<DeprecatedString> debug_description() const;
 };}
 } // namespace Jakt
@@ -126,14 +126,14 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::codegen::LineSpan> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::codegen::LineSpan const& value) {
+template<>struct Jakt::Formatter<Jakt::codegen::CodeGenerator> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::codegen::CodeGenerator const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::codegen::CodeGenerator> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::codegen::CodeGenerator const& value) {
+template<>struct Jakt::Formatter<Jakt::codegen::LineSpan> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::codegen::LineSpan const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
diff --git a/bootstrap/stage0/compiler.cpp b/bootstrap/stage0/compiler.cpp
index c159e6dd7..e6ce0838f 100644
--- a/bootstrap/stage0/compiler.cpp
+++ b/bootstrap/stage0/compiler.cpp
@@ -30,67 +30,6 @@ TRY((((*this).get_file_id_or_register(file_name))));
 return {};
 }
 
-ErrorOr<JaktInternal::Optional<jakt__path::Path>> compiler::Compiler::get_file_path(utility::FileId const file_id) const {
-{
-if ((((file_id).id) >= ((((*this).files)).size()))){
-return (JaktInternal::OptionalNone());
-}
-return (((((*this).files))[((file_id).id)]));
-}
-}
-
-bool compiler::Compiler::set_current_file(utility::FileId const file_id) {
-{
-i32 const ErrNOENT = static_cast<i32>(2);
-i32 const ErrACCES = static_cast<i32>(13);
-i32 const ErrFBIG = static_cast<i32>(27);
-i32 const ErrNAMETOOLONG = static_cast<i32>(36);
-JaktInternal::Optional<utility::FileId> const old_file_id = ((*this).current_file);
-(((*this).current_file) = file_id);
-auto __jakt_var_0 = [&]() -> ErrorOr<void> {{
-NonnullRefPtr<File> file = TRY((File::open_for_reading(((((((*this).files))[((file_id).id)])).to_string()))));
-(((*this).current_file_contents) = TRY((((file)->read_all()))));
-}
-
-;return {};}();
-if (__jakt_var_0.is_error()) {auto error = __jakt_var_0.release_error();{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,bool>{
-auto __jakt_enum_value = (((error).code()));
-if (__jakt_enum_value == ErrNOENT) {
-return (warnln(Jakt::DeprecatedString("\u001b[31;1mError\u001b[0m Could not access {}: File not found"sv),((((*this).files))[((file_id).id)]))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == ErrACCES) {
-return (warnln(Jakt::DeprecatedString("\u001b[31;1mError\u001b[0m Could not access {}: Permission denied"sv),((((*this).files))[((file_id).id)]))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == ErrFBIG) {
-return (warnln(Jakt::DeprecatedString("\u001b[31;1mError\u001b[0m Could not access {}: File too big"sv),((((*this).files))[((file_id).id)]))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == ErrNAMETOOLONG) {
-return (warnln(Jakt::DeprecatedString("\u001b[31;1mError\u001b[0m Could not access {}: Name too long"sv),((((*this).files))[((file_id).id)]))), JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-utility::panic(Jakt::DeprecatedString("Incurred unrecognized error while trying to open file"sv));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-(((*this).current_file) = old_file_id);
-return (false);
-}
-};
-return (true);
-}
-}
-
-JaktInternal::Tuple<JaktInternal::Optional<utility::FileId>,JaktInternal::DynamicArray<u8>> compiler::Compiler::current_file_state() const {
-{
-return ((Tuple{((*this).current_file), ((*this).current_file_contents)}));
-}
-}
-
 ErrorOr<JaktInternal::Optional<jakt__path::Path>> compiler::Compiler::search_for_path(DeprecatedString const input_module_name) const {
 {
 DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
@@ -152,26 +91,6 @@ return (JaktInternal::OptionalNone());
 }
 }
 
-ErrorOr<utility::FileId> compiler::Compiler::get_file_id_or_register(jakt__path::Path const file) {
-{
-DeprecatedString const path = ((file).to_string());
-JaktInternal::Optional<utility::FileId> file_id = ((((*this).file_ids)).get(path));
-if (((file_id).has_value())){
-return ((file_id.value()));
-}
-TRY((((((*this).files)).push(file))));
-(file_id = utility::FileId((JaktInternal::checked_sub<size_t>(((((*this).files)).size()),static_cast<size_t>(1ULL)))));
-TRY((((((*this).file_ids)).set(path,(file_id.value())))));
-return ((file_id.value()));
-}
-}
-
-JaktInternal::Optional<utility::FileId> compiler::Compiler::current_file_id() const {
-{
-return (((*this).current_file));
-}
-}
-
 void compiler::Compiler::restore_file_state(JaktInternal::Tuple<JaktInternal::Optional<utility::FileId>,JaktInternal::DynamicArray<u8>> const state) {
 {
 (((*this).current_file) = ((state).template get<0>()));
@@ -179,8 +98,6 @@ void compiler::Compiler::restore_file_state(JaktInternal::Tuple<JaktInternal::Op
 }
 }
 
-compiler::Compiler::Compiler(JaktInternal::DynamicArray<jakt__path::Path> a_files, JaktInternal::Dictionary<DeprecatedString,utility::FileId> a_file_ids, JaktInternal::DynamicArray<error::JaktError> a_errors, JaktInternal::Optional<utility::FileId> a_current_file, JaktInternal::DynamicArray<u8> a_current_file_contents, bool a_dump_lexer, bool a_dump_parser, bool a_ignore_parser_errors, bool a_debug_print, jakt__path::Path a_std_include_path, JaktInternal::DynamicArray<DeprecatedString> a_include_paths, bool a_json_errors, bool a_dump_type_hints, bool a_dump_try_hints, bool a_optimize, JaktInternal::Optional<DeprecatedString> a_target_triple): files(move(a_files)), file_ids(move(a_file_ids)), errors(move(a_errors)), current_file(move(a_current_file)), current_file_contents(move(a_current_file_contents)), dump_lexer(move(a_dump_lexer)), dump_parser(move(a_dump_parser)), ignore_parser_errors(move(a_ignore_parser_errors)), debug_print(move(a_debug_print)), std_include_path(move(a_std_include_path)), include_paths(move(a_include_paths)), json_errors(move(a_json_errors)), dump_type_hints(move(a_dump_type_hints)), dump_try_hints(move(a_dump_try_hints)), optimize(move(a_optimize)), target_triple(move(a_target_triple)){}
-ErrorOr<NonnullRefPtr<Compiler>> compiler::Compiler::__jakt_create(JaktInternal::DynamicArray<jakt__path::Path> files, JaktInternal::Dictionary<DeprecatedString,utility::FileId> file_ids, JaktInternal::DynamicArray<error::JaktError> errors, JaktInternal::Optional<utility::FileId> current_file, JaktInternal::DynamicArray<u8> current_file_contents, bool dump_lexer, bool dump_parser, bool ignore_parser_errors, bool debug_print, jakt__path::Path std_include_path, JaktInternal::DynamicArray<DeprecatedString> include_paths, bool json_errors, bool dump_type_hints, bool dump_try_hints, bool optimize, JaktInternal::Optional<DeprecatedString> target_triple) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Compiler (move(files), move(file_ids), move(errors), move(current_file), move(current_file_contents), move(dump_lexer), move(dump_parser), move(ignore_parser_errors), move(debug_print), move(std_include_path), move(include_paths), move(json_errors), move(dump_type_hints), move(dump_try_hints), move(optimize), move(target_triple)))); return o; }
 JaktInternal::Optional<jakt__path::Path> compiler::Compiler::current_file_path() const {
 {
 if (((((*this).current_file)).has_value())){
@@ -190,10 +107,9 @@ return (JaktInternal::OptionalNone());
 }
 }
 
-[[noreturn]] ErrorOr<void> compiler::Compiler::panic(DeprecatedString const message) const {
+JaktInternal::Tuple<JaktInternal::Optional<utility::FileId>,JaktInternal::DynamicArray<u8>> compiler::Compiler::current_file_state() const {
 {
-MUST((((*this).print_errors())));
-utility::panic(message);
+return ((Tuple{((*this).current_file), ((*this).current_file_contents)}));
 }
 }
 
@@ -227,13 +143,13 @@ TRY((error::print_error_json(file_name,error)));
 }
 else {
 if ((!(((file_contents).has_value())))){
-auto __jakt_var_1 = [&]() -> ErrorOr<void> {{
+auto __jakt_var_0 = [&]() -> ErrorOr<void> {{
 NonnullRefPtr<File> file = TRY((File::open_for_reading(file_name)));
 (file_contents = TRY((((file)->read_all()))));
 }
 
 ;return {};}();
-if (__jakt_var_1.is_error()) {auto error = __jakt_var_1.release_error();{
+if (__jakt_var_0.is_error()) {auto error = __jakt_var_0.release_error();{
 }
 };
 }
@@ -264,5 +180,89 @@ outln(Jakt::DeprecatedString("{}"sv),message);
 }
 }
 
+compiler::Compiler::Compiler(JaktInternal::DynamicArray<jakt__path::Path> a_files, JaktInternal::Dictionary<DeprecatedString,utility::FileId> a_file_ids, JaktInternal::DynamicArray<error::JaktError> a_errors, JaktInternal::Optional<utility::FileId> a_current_file, JaktInternal::DynamicArray<u8> a_current_file_contents, bool a_dump_lexer, bool a_dump_parser, bool a_ignore_parser_errors, bool a_debug_print, jakt__path::Path a_std_include_path, JaktInternal::DynamicArray<DeprecatedString> a_include_paths, bool a_json_errors, bool a_dump_type_hints, bool a_dump_try_hints, bool a_optimize, JaktInternal::Optional<DeprecatedString> a_target_triple): files(move(a_files)), file_ids(move(a_file_ids)), errors(move(a_errors)), current_file(move(a_current_file)), current_file_contents(move(a_current_file_contents)), dump_lexer(move(a_dump_lexer)), dump_parser(move(a_dump_parser)), ignore_parser_errors(move(a_ignore_parser_errors)), debug_print(move(a_debug_print)), std_include_path(move(a_std_include_path)), include_paths(move(a_include_paths)), json_errors(move(a_json_errors)), dump_type_hints(move(a_dump_type_hints)), dump_try_hints(move(a_dump_try_hints)), optimize(move(a_optimize)), target_triple(move(a_target_triple)){}
+ErrorOr<NonnullRefPtr<Compiler>> compiler::Compiler::__jakt_create(JaktInternal::DynamicArray<jakt__path::Path> files, JaktInternal::Dictionary<DeprecatedString,utility::FileId> file_ids, JaktInternal::DynamicArray<error::JaktError> errors, JaktInternal::Optional<utility::FileId> current_file, JaktInternal::DynamicArray<u8> current_file_contents, bool dump_lexer, bool dump_parser, bool ignore_parser_errors, bool debug_print, jakt__path::Path std_include_path, JaktInternal::DynamicArray<DeprecatedString> include_paths, bool json_errors, bool dump_type_hints, bool dump_try_hints, bool optimize, JaktInternal::Optional<DeprecatedString> target_triple) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Compiler (move(files), move(file_ids), move(errors), move(current_file), move(current_file_contents), move(dump_lexer), move(dump_parser), move(ignore_parser_errors), move(debug_print), move(std_include_path), move(include_paths), move(json_errors), move(dump_type_hints), move(dump_try_hints), move(optimize), move(target_triple)))); return o; }
+JaktInternal::Optional<utility::FileId> compiler::Compiler::current_file_id() const {
+{
+return (((*this).current_file));
+}
+}
+
+ErrorOr<JaktInternal::Optional<jakt__path::Path>> compiler::Compiler::get_file_path(utility::FileId const file_id) const {
+{
+if ((((file_id).id) >= ((((*this).files)).size()))){
+return (JaktInternal::OptionalNone());
+}
+return (((((*this).files))[((file_id).id)]));
+}
+}
+
+ErrorOr<utility::FileId> compiler::Compiler::get_file_id_or_register(jakt__path::Path const file) {
+{
+DeprecatedString const path = ((file).to_string());
+JaktInternal::Optional<utility::FileId> file_id = ((((*this).file_ids)).get(path));
+if (((file_id).has_value())){
+return ((file_id.value()));
+}
+TRY((((((*this).files)).push(file))));
+(file_id = utility::FileId((JaktInternal::checked_sub<size_t>(((((*this).files)).size()),static_cast<size_t>(1ULL)))));
+TRY((((((*this).file_ids)).set(path,(file_id.value())))));
+return ((file_id.value()));
+}
+}
+
+bool compiler::Compiler::set_current_file(utility::FileId const file_id) {
+{
+i32 const ErrNOENT = static_cast<i32>(2);
+i32 const ErrACCES = static_cast<i32>(13);
+i32 const ErrFBIG = static_cast<i32>(27);
+i32 const ErrNAMETOOLONG = static_cast<i32>(36);
+JaktInternal::Optional<utility::FileId> const old_file_id = ((*this).current_file);
+(((*this).current_file) = file_id);
+auto __jakt_var_1 = [&]() -> ErrorOr<void> {{
+NonnullRefPtr<File> file = TRY((File::open_for_reading(((((((*this).files))[((file_id).id)])).to_string()))));
+(((*this).current_file_contents) = TRY((((file)->read_all()))));
+}
+
+;return {};}();
+if (__jakt_var_1.is_error()) {auto error = __jakt_var_1.release_error();{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,bool>{
+auto __jakt_enum_value = (((error).code()));
+if (__jakt_enum_value == ErrNOENT) {
+return (warnln(Jakt::DeprecatedString("\u001b[31;1mError\u001b[0m Could not access {}: File not found"sv),((((*this).files))[((file_id).id)]))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == ErrACCES) {
+return (warnln(Jakt::DeprecatedString("\u001b[31;1mError\u001b[0m Could not access {}: Permission denied"sv),((((*this).files))[((file_id).id)]))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == ErrFBIG) {
+return (warnln(Jakt::DeprecatedString("\u001b[31;1mError\u001b[0m Could not access {}: File too big"sv),((((*this).files))[((file_id).id)]))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == ErrNAMETOOLONG) {
+return (warnln(Jakt::DeprecatedString("\u001b[31;1mError\u001b[0m Could not access {}: Name too long"sv),((((*this).files))[((file_id).id)]))), JaktInternal::ExplicitValue<void>();
+}
+else {
+{
+utility::panic(Jakt::DeprecatedString("Incurred unrecognized error while trying to open file"sv));
+}
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+(((*this).current_file) = old_file_id);
+return (false);
+}
+};
+return (true);
+}
+}
+
+[[noreturn]] ErrorOr<void> compiler::Compiler::panic(DeprecatedString const message) const {
+{
+MUST((((*this).print_errors())));
+utility::panic(message);
+}
+}
+
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/compiler.h b/bootstrap/stage0/compiler.h
index 3c286ef29..a3acdb492 100644
--- a/bootstrap/stage0/compiler.h
+++ b/bootstrap/stage0/compiler.h
@@ -10,22 +10,22 @@ class Compiler : public RefCounted<Compiler>, public Weakable<Compiler> {
   public:
 virtual ~Compiler() = default;
 JaktInternal::DynamicArray<jakt__path::Path> files;JaktInternal::Dictionary<DeprecatedString,utility::FileId> file_ids;JaktInternal::DynamicArray<error::JaktError> errors;JaktInternal::Optional<utility::FileId> current_file;JaktInternal::DynamicArray<u8> current_file_contents;bool dump_lexer;bool dump_parser;bool ignore_parser_errors;bool debug_print;jakt__path::Path std_include_path;JaktInternal::DynamicArray<DeprecatedString> include_paths;bool json_errors;bool dump_type_hints;bool dump_try_hints;bool optimize;JaktInternal::Optional<DeprecatedString> target_triple;ErrorOr<void> load_prelude();
-ErrorOr<JaktInternal::Optional<jakt__path::Path>> get_file_path(utility::FileId const file_id) const;
-bool set_current_file(utility::FileId const file_id);
-JaktInternal::Tuple<JaktInternal::Optional<utility::FileId>,JaktInternal::DynamicArray<u8>> current_file_state() const;
 ErrorOr<JaktInternal::Optional<jakt__path::Path>> search_for_path(DeprecatedString const input_module_name) const;
-ErrorOr<utility::FileId> get_file_id_or_register(jakt__path::Path const file);
-JaktInternal::Optional<utility::FileId> current_file_id() const;
 void restore_file_state(JaktInternal::Tuple<JaktInternal::Optional<utility::FileId>,JaktInternal::DynamicArray<u8>> const state);
+JaktInternal::Optional<jakt__path::Path> current_file_path() const;
+JaktInternal::Tuple<JaktInternal::Optional<utility::FileId>,JaktInternal::DynamicArray<u8>> current_file_state() const;
+ErrorOr<void> print_errors() const;
+void dbg_println(DeprecatedString const message) const;
 protected:
 explicit Compiler(JaktInternal::DynamicArray<jakt__path::Path> a_files, JaktInternal::Dictionary<DeprecatedString,utility::FileId> a_file_ids, JaktInternal::DynamicArray<error::JaktError> a_errors, JaktInternal::Optional<utility::FileId> a_current_file, JaktInternal::DynamicArray<u8> a_current_file_contents, bool a_dump_lexer, bool a_dump_parser, bool a_ignore_parser_errors, bool a_debug_print, jakt__path::Path a_std_include_path, JaktInternal::DynamicArray<DeprecatedString> a_include_paths, bool a_json_errors, bool a_dump_type_hints, bool a_dump_try_hints, bool a_optimize, JaktInternal::Optional<DeprecatedString> a_target_triple);
 public:
 static ErrorOr<NonnullRefPtr<Compiler>> __jakt_create(JaktInternal::DynamicArray<jakt__path::Path> files, JaktInternal::Dictionary<DeprecatedString,utility::FileId> file_ids, JaktInternal::DynamicArray<error::JaktError> errors, JaktInternal::Optional<utility::FileId> current_file, JaktInternal::DynamicArray<u8> current_file_contents, bool dump_lexer, bool dump_parser, bool ignore_parser_errors, bool debug_print, jakt__path::Path std_include_path, JaktInternal::DynamicArray<DeprecatedString> include_paths, bool json_errors, bool dump_type_hints, bool dump_try_hints, bool optimize, JaktInternal::Optional<DeprecatedString> target_triple);
 
-JaktInternal::Optional<jakt__path::Path> current_file_path() const;
+JaktInternal::Optional<utility::FileId> current_file_id() const;
+ErrorOr<JaktInternal::Optional<jakt__path::Path>> get_file_path(utility::FileId const file_id) const;
+ErrorOr<utility::FileId> get_file_id_or_register(jakt__path::Path const file);
+bool set_current_file(utility::FileId const file_id);
 [[noreturn]] ErrorOr<void> panic(DeprecatedString const message) const;
-ErrorOr<void> print_errors() const;
-void dbg_println(DeprecatedString const message) const;
 ErrorOr<DeprecatedString> debug_description() const;
 };}
 } // namespace Jakt
diff --git a/bootstrap/stage0/error.cpp b/bootstrap/stage0/error.cpp
index 19dcc3ded..d51fc7b8b 100644
--- a/bootstrap/stage0/error.cpp
+++ b/bootstrap/stage0/error.cpp
@@ -32,23 +32,35 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 return {};
 }
 
-ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,size_t>>> gather_line_spans(JaktInternal::DynamicArray<u8> const file_contents) {
+ErrorOr<void> print_error(DeprecatedString const file_name,JaktInternal::Optional<JaktInternal::DynamicArray<u8>> const file_contents,error::JaktError const error) {
 {
-size_t idx = static_cast<size_t>(0ULL);
-JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,size_t>> output = (TRY((DynamicArray<JaktInternal::Tuple<size_t,size_t>>::create_with({}))));
-size_t start = idx;
-while ((idx < ((file_contents).size()))){
-if ((((file_contents)[idx]) == '\n')){
-TRY((((output).push((Tuple{start, idx})))));
-(start = (JaktInternal::checked_add<size_t>(idx,static_cast<size_t>(1ULL))));
-}
-({auto& _jakt_ref = idx;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = error;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<error::JaktError::Message>();DeprecatedString const& message = __jakt_match_value.message;
+utility::Span const& span = __jakt_match_value.span;
+{
+TRY((error::display_message_with_span( error::MessageSeverity { typename error::MessageSeverity::Error() } ,file_name,file_contents,message,span)));
 }
-if ((start <= idx)){
-TRY((((output).push((Tuple{start, idx})))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<error::JaktError::MessageWithHint>();DeprecatedString const& message = __jakt_match_value.message;
+utility::Span const& span = __jakt_match_value.span;
+DeprecatedString const& hint = __jakt_match_value.hint;
+utility::Span const& hint_span = __jakt_match_value.hint_span;
+{
+TRY((error::display_message_with_span( error::MessageSeverity { typename error::MessageSeverity::Error() } ,file_name,file_contents,message,span)));
+TRY((error::display_message_with_span( error::MessageSeverity { typename error::MessageSeverity::Hint() } ,file_name,file_contents,hint,hint_span)));
 }
-return (output);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
 }
+return {};
 }
 
 ErrorOr<void> display_message_with_span(error::MessageSeverity const severity,DeprecatedString const file_name,JaktInternal::Optional<JaktInternal::DynamicArray<u8>> const contents,DeprecatedString const message,utility::Span const span) {
@@ -158,6 +170,25 @@ warnln(Jakt::DeprecatedString("┴─"sv));
 return {};
 }
 
+ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,size_t>>> gather_line_spans(JaktInternal::DynamicArray<u8> const file_contents) {
+{
+size_t idx = static_cast<size_t>(0ULL);
+JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,size_t>> output = (TRY((DynamicArray<JaktInternal::Tuple<size_t,size_t>>::create_with({}))));
+size_t start = idx;
+while ((idx < ((file_contents).size()))){
+if ((((file_contents)[idx]) == '\n')){
+TRY((((output).push((Tuple{start, idx})))));
+(start = (JaktInternal::checked_add<size_t>(idx,static_cast<size_t>(1ULL))));
+}
+({auto& _jakt_ref = idx;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+}
+if ((start <= idx)){
+TRY((((output).push((Tuple{start, idx})))));
+}
+return (output);
+}
+}
+
 ErrorOr<void> print_underline(error::MessageSeverity const severity,size_t const width,JaktInternal::Tuple<size_t,size_t> const file_span,utility::Span const error_span,size_t const line_number,size_t const largest_line_number) {
 {
 {
@@ -259,35 +290,49 @@ outln(Jakt::DeprecatedString("{{\"type\":\"diagnostic\",\"message\":\"{}\",\"sev
 return {};
 }
 
-ErrorOr<void> print_error(DeprecatedString const file_name,JaktInternal::Optional<JaktInternal::DynamicArray<u8>> const file_contents,error::JaktError const error) {
+ErrorOr<DeprecatedString> error::MessageSeverity::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Hint */: {
+return DeprecatedString("MessageSeverity::Hint"sv);
+break;}
+case 1 /* Error */: {
+return DeprecatedString("MessageSeverity::Error"sv);
+break;}
+}
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> error::MessageSeverity::ansi_color_code() const {
 {
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = error;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<error::JaktError::Message>();DeprecatedString const& message = __jakt_match_value.message;
-utility::Span const& span = __jakt_match_value.span;
-{
-TRY((error::display_message_with_span( error::MessageSeverity { typename error::MessageSeverity::Error() } ,file_name,file_contents,message,span)));
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("94"sv));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<error::JaktError::MessageWithHint>();DeprecatedString const& message = __jakt_match_value.message;
-utility::Span const& span = __jakt_match_value.span;
-DeprecatedString const& hint = __jakt_match_value.hint;
-utility::Span const& hint_span = __jakt_match_value.hint_span;
-{
-TRY((error::display_message_with_span( error::MessageSeverity { typename error::MessageSeverity::Error() } ,file_name,file_contents,message,span)));
-TRY((error::display_message_with_span( error::MessageSeverity { typename error::MessageSeverity::Hint() } ,file_name,file_contents,hint,hint_span)));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("31"sv));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-return JaktInternal::ExplicitValue<void>();
+}
+
+ErrorOr<DeprecatedString> error::MessageSeverity::name() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Hint"sv));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Error"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-));
+)));
 }
-return {};
 }
 
 ErrorOr<DeprecatedString> error::JaktError::debug_description() const {
@@ -348,50 +393,5 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-ErrorOr<DeprecatedString> error::MessageSeverity::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Hint */: {
-return DeprecatedString("MessageSeverity::Hint"sv);
-break;}
-case 1 /* Error */: {
-return DeprecatedString("MessageSeverity::Error"sv);
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> error::MessageSeverity::ansi_color_code() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("94"sv));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("31"sv));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<DeprecatedString> error::MessageSeverity::name() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Hint"sv));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Error"sv));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/formatter.cpp b/bootstrap/stage0/formatter.cpp
index e442dcb3c..23ba373d0 100644
--- a/bootstrap/stage0/formatter.cpp
+++ b/bootstrap/stage0/formatter.cpp
@@ -1127,58 +1127,6 @@ return ((((state).index() == 11 /* TypeContext */) || ((state).index() == 9 /* V
 }
 }
 
-formatter::Formatter::Formatter(formatter::Stage0 a_token_provider, JaktInternal::DynamicArray<formatter::ReflowState> a_current_line, size_t a_current_line_length, size_t a_max_allowed_line_length, JaktInternal::DynamicArray<formatter::BreakablePoint> a_breakable_points_in_current_line, JaktInternal::DynamicArray<formatter::ReflowState> a_tokens_to_reflow, JaktInternal::DynamicArray<JaktInternal::Optional<lexer::Token>> a_replace_commas_in_enclosure, size_t a_enclosures_to_ignore, bool a_in_condition_expr, bool a_in_condition_expr_indented, JaktInternal::Optional<size_t> a_logical_break_indent, size_t a_empty_line_count) :token_provider(move(a_token_provider)), current_line(move(a_current_line)), current_line_length(move(a_current_line_length)), max_allowed_line_length(move(a_max_allowed_line_length)), breakable_points_in_current_line(move(a_breakable_points_in_current_line)), tokens_to_reflow(move(a_tokens_to_reflow)), replace_commas_in_enclosure(move(a_replace_commas_in_enclosure)), enclosures_to_ignore(move(a_enclosures_to_ignore)), in_condition_expr(move(a_in_condition_expr)), in_condition_expr_indented(move(a_in_condition_expr_indented)), logical_break_indent(move(a_logical_break_indent)), empty_line_count(move(a_empty_line_count)){}
-
-ErrorOr<size_t> formatter::Formatter::token_length(formatter::FormattedToken const token) const {
-{
-size_t length = ((((token).preceding_trivia)).size());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<size_t>>{
-auto&& __jakt_match_variant = ((token).token);
-switch(__jakt_match_variant.index()) {
-case 55: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Eol>();JaktInternal::Optional<DeprecatedString> const& comment = __jakt_match_value.comment;
-{
-if (((comment).has_value())){
-u8 next_char = ' ';
-if (((((comment.value())).length()) != static_cast<size_t>(0ULL))){
-(next_char = (((comment.value())).byte_at(static_cast<size_t>(0ULL))));
-}
-size_t const space = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,ErrorOr<size_t>>{
-auto __jakt_enum_value = (next_char);
-if (__jakt_enum_value == ' ') {
-return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
-}
-else if (__jakt_enum_value == '\t') {
-return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
-}
-else if (__jakt_enum_value == '/') {
-return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
-}
-else {
-return JaktInternal::ExplicitValue(static_cast<size_t>(1ULL));
-}
-}()))
-;
-({auto& _jakt_ref = length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, space);});
-({auto& _jakt_ref = length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, (((comment.value())).length()));});
-}
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-({auto& _jakt_ref = length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, ((TRY((((token).token_text())))).length()));});
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-({auto& _jakt_ref = length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, ((((token).trailing_trivia)).size()));});
-return (length);
-}
-}
-
 ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> formatter::Formatter::peek() {
 {
 JaktInternal::Optional<formatter::ReflowState> reflown_token = JaktInternal::OptionalNone();
@@ -1236,6 +1184,58 @@ formatter::ReflowState const a = ((((*this).tokens_to_reflow))[i]);
 return {};
 }
 
+formatter::Formatter::Formatter(formatter::Stage0 a_token_provider, JaktInternal::DynamicArray<formatter::ReflowState> a_current_line, size_t a_current_line_length, size_t a_max_allowed_line_length, JaktInternal::DynamicArray<formatter::BreakablePoint> a_breakable_points_in_current_line, JaktInternal::DynamicArray<formatter::ReflowState> a_tokens_to_reflow, JaktInternal::DynamicArray<JaktInternal::Optional<lexer::Token>> a_replace_commas_in_enclosure, size_t a_enclosures_to_ignore, bool a_in_condition_expr, bool a_in_condition_expr_indented, JaktInternal::Optional<size_t> a_logical_break_indent, size_t a_empty_line_count) :token_provider(move(a_token_provider)), current_line(move(a_current_line)), current_line_length(move(a_current_line_length)), max_allowed_line_length(move(a_max_allowed_line_length)), breakable_points_in_current_line(move(a_breakable_points_in_current_line)), tokens_to_reflow(move(a_tokens_to_reflow)), replace_commas_in_enclosure(move(a_replace_commas_in_enclosure)), enclosures_to_ignore(move(a_enclosures_to_ignore)), in_condition_expr(move(a_in_condition_expr)), in_condition_expr_indented(move(a_in_condition_expr_indented)), logical_break_indent(move(a_logical_break_indent)), empty_line_count(move(a_empty_line_count)){}
+
+ErrorOr<size_t> formatter::Formatter::token_length(formatter::FormattedToken const token) const {
+{
+size_t length = ((((token).preceding_trivia)).size());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<size_t>>{
+auto&& __jakt_match_variant = ((token).token);
+switch(__jakt_match_variant.index()) {
+case 55: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Eol>();JaktInternal::Optional<DeprecatedString> const& comment = __jakt_match_value.comment;
+{
+if (((comment).has_value())){
+u8 next_char = ' ';
+if (((((comment.value())).length()) != static_cast<size_t>(0ULL))){
+(next_char = (((comment.value())).byte_at(static_cast<size_t>(0ULL))));
+}
+size_t const space = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,ErrorOr<size_t>>{
+auto __jakt_enum_value = (next_char);
+if (__jakt_enum_value == ' ') {
+return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
+}
+else if (__jakt_enum_value == '\t') {
+return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
+}
+else if (__jakt_enum_value == '/') {
+return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
+}
+else {
+return JaktInternal::ExplicitValue(static_cast<size_t>(1ULL));
+}
+}()))
+;
+({auto& _jakt_ref = length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, space);});
+({auto& _jakt_ref = length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, (((comment.value())).length()));});
+}
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+({auto& _jakt_ref = length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, ((TRY((((token).token_text())))).length()));});
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+({auto& _jakt_ref = length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, ((((token).trailing_trivia)).size()));});
+return (length);
+}
+}
+
 ErrorOr<void> formatter::Formatter::fixup_closing_enclosures(JaktInternal::DynamicArray<formatter::ReflowState>& line) const {
 {
 if (((((line))).is_empty())){
@@ -1338,54 +1338,6 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("debug: {}", debug));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> formatter::Stage0::next() {
-{
-return (TRY((((*this).next_impl(false)))));
-}
-}
-
-ErrorOr<void> formatter::Stage0::replace_state(formatter::State const state) {
-{
-JaktInternal::Optional<formatter::State> const dummy = ((((*this).states)).pop());
-TRY((((((*this).states)).push(state))));
-}
-return {};
-}
-
-formatter::State formatter::Stage0::state() const {
-{
-return ((((((*this).states)).last()).value()));
-}
-}
-
-ErrorOr<void> formatter::Stage0::push_state(formatter::State const state) {
-{
-TRY((((((*this).states)).push(state))));
-}
-return {};
-}
-
-ErrorOr<formatter::Stage0> formatter::Stage0::for_tokens(JaktInternal::DynamicArray<lexer::Token> const tokens,bool const debug) {
-{
-return (formatter::Stage0(tokens,static_cast<size_t>(0ULL),(TRY((DynamicArray<formatter::State>::create_with({ formatter::State { typename formatter::State::Toplevel(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)) } })))),static_cast<size_t>(0ULL),false,(TRY((DynamicArray<size_t>::create_with({static_cast<size_t>(0ULL)})))),debug));
-}
-}
-
-ErrorOr<formatter::Stage0> formatter::Stage0::create(NonnullRefPtr<compiler::Compiler> compiler,JaktInternal::DynamicArray<u8> const source,bool const debug) {
-{
-JaktInternal::DynamicArray<u8> const old_file_contents = ((compiler)->current_file_contents);
-(((compiler)->current_file_contents) = source);
-ScopeGuard __jakt_var_596([&] {
-{
-(((compiler)->current_file_contents) = old_file_contents);
-}
-
-});
-JaktInternal::DynamicArray<lexer::Token> const tokens = TRY((lexer::Lexer::lex(compiler)));
-return (formatter::Stage0(tokens,static_cast<size_t>(0ULL),(TRY((DynamicArray<formatter::State>::create_with({ formatter::State { typename formatter::State::Toplevel(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)) } })))),static_cast<size_t>(0ULL),false,(TRY((DynamicArray<size_t>::create_with({static_cast<size_t>(0ULL)})))),debug));
-}
-}
-
 ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> formatter::Stage0::next_impl(bool const reconsume) {
 {
 if ((((*this).index) >= ((((*this).tokens)).size()))){
@@ -1421,7 +1373,7 @@ else if (((((((*this).dedents_to_skip)).last()).value()) > static_cast<size_t>(0
 }
 }
 }
-ScopeGuard __jakt_var_597([&] {
+ScopeGuard __jakt_var_596([&] {
 {
 if ((indent_change > static_cast<i64>(0LL))){
 ({auto& _jakt_ref = ((*this).indent);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, (infallible_integer_cast<size_t>((indent_change))));});
@@ -1463,155 +1415,155 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 71: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_598; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_597; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::EntityDeclaration(formatter::Entity::from_token(((token))),(!(((token).index() == 85 /* Namespace */))),false,static_cast<size_t>(0ULL)) } ))));
 JaktInternal::DynamicArray<u8> trailing_trivia = (TRY((DynamicArray<u8>::create_with({}))));
 if ((((token).index() == 85 /* Namespace */) || (!(((((*this).peek(static_cast<i64>(0LL)))).index() == 28 /* LessThan */))))){
 TRY((((trailing_trivia).push(' '))));
 }
-__jakt_var_598 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_521;
+__jakt_var_597 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_521;
 
 }
-__jakt_label_521:; __jakt_var_598.release_value(); }));
+__jakt_label_521:; __jakt_var_597.release_value(); }));
 };/*case end*/
 case 65: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_599; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_598; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::EntityDeclaration(formatter::Entity::from_token(((token))),(!(((token).index() == 85 /* Namespace */))),false,static_cast<size_t>(0ULL)) } ))));
 JaktInternal::DynamicArray<u8> trailing_trivia = (TRY((DynamicArray<u8>::create_with({}))));
 if ((((token).index() == 85 /* Namespace */) || (!(((((*this).peek(static_cast<i64>(0LL)))).index() == 28 /* LessThan */))))){
 TRY((((trailing_trivia).push(' '))));
 }
-__jakt_var_599 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_522;
+__jakt_var_598 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_522;
 
 }
-__jakt_label_522:; __jakt_var_599.release_value(); }));
+__jakt_label_522:; __jakt_var_598.release_value(); }));
 };/*case end*/
 case 96: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_600; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_599; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::EntityDeclaration(formatter::Entity::from_token(((token))),(!(((token).index() == 85 /* Namespace */))),false,static_cast<size_t>(0ULL)) } ))));
 JaktInternal::DynamicArray<u8> trailing_trivia = (TRY((DynamicArray<u8>::create_with({}))));
 if ((((token).index() == 85 /* Namespace */) || (!(((((*this).peek(static_cast<i64>(0LL)))).index() == 28 /* LessThan */))))){
 TRY((((trailing_trivia).push(' '))));
 }
-__jakt_var_600 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_523;
+__jakt_var_599 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_523;
 
 }
-__jakt_label_523:; __jakt_var_600.release_value(); }));
+__jakt_label_523:; __jakt_var_599.release_value(); }));
 };/*case end*/
 case 75: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_601; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_600; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::EntityDeclaration(formatter::Entity::from_token(((token))),(!(((token).index() == 85 /* Namespace */))),false,static_cast<size_t>(0ULL)) } ))));
 JaktInternal::DynamicArray<u8> trailing_trivia = (TRY((DynamicArray<u8>::create_with({}))));
 if ((((token).index() == 85 /* Namespace */) || (!(((((*this).peek(static_cast<i64>(0LL)))).index() == 28 /* LessThan */))))){
 TRY((((trailing_trivia).push(' '))));
 }
-__jakt_var_601 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_524;
+__jakt_var_600 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_524;
 
 }
-__jakt_label_524:; __jakt_var_601.release_value(); }));
+__jakt_label_524:; __jakt_var_600.release_value(); }));
 };/*case end*/
 case 76: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_602; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_601; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::EntityDeclaration(formatter::Entity::from_token(((token))),(!(((token).index() == 85 /* Namespace */))),false,static_cast<size_t>(0ULL)) } ))));
 JaktInternal::DynamicArray<u8> trailing_trivia = (TRY((DynamicArray<u8>::create_with({}))));
 if ((((token).index() == 85 /* Namespace */) || (!(((((*this).peek(static_cast<i64>(0LL)))).index() == 28 /* LessThan */))))){
 TRY((((trailing_trivia).push(' '))));
 }
-__jakt_var_602 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_525;
+__jakt_var_601 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_525;
 
 }
-__jakt_label_525:; __jakt_var_602.release_value(); }));
+__jakt_label_525:; __jakt_var_601.release_value(); }));
 };/*case end*/
 case 85: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_603; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_602; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::EntityDeclaration(formatter::Entity::from_token(((token))),(!(((token).index() == 85 /* Namespace */))),false,static_cast<size_t>(0ULL)) } ))));
 JaktInternal::DynamicArray<u8> trailing_trivia = (TRY((DynamicArray<u8>::create_with({}))));
 if ((((token).index() == 85 /* Namespace */) || (!(((((*this).peek(static_cast<i64>(0LL)))).index() == 28 /* LessThan */))))){
 TRY((((trailing_trivia).push(' '))));
 }
-__jakt_var_603 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_526;
+__jakt_var_602 = formatter::FormattedToken(token,((*this).indent),trailing_trivia,(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_526;
 
 }
-__jakt_label_526:; __jakt_var_603.release_value(); }));
+__jakt_label_526:; __jakt_var_602.release_value(); }));
 };/*case end*/
 case 11: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_604; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_603; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::Toplevel(open_parens,open_curlies,(JaktInternal::checked_add<size_t>(open_squares,static_cast<size_t>(1ULL)))) } ))));
-__jakt_var_604 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_527;
+__jakt_var_603 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_527;
 
 }
-__jakt_label_527:; __jakt_var_604.release_value(); }));
+__jakt_label_527:; __jakt_var_603.release_value(); }));
 };/*case end*/
 case 12: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_605; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_604; {
 if ((open_squares == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::Toplevel(open_parens,open_curlies,(JaktInternal::checked_sub<size_t>(open_squares,static_cast<size_t>(1ULL)))) } ))));
-__jakt_var_605 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_528;
+__jakt_var_604 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_528;
 
 }
-__jakt_label_528:; __jakt_var_605.release_value(); }));
+__jakt_label_528:; __jakt_var_604.release_value(); }));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_606; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_605; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::Toplevel((JaktInternal::checked_add<size_t>(open_parens,static_cast<size_t>(1ULL))),open_curlies,open_squares) } ))));
-__jakt_var_606 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_529;
+__jakt_var_605 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_529;
 
 }
-__jakt_label_529:; __jakt_var_606.release_value(); }));
+__jakt_label_529:; __jakt_var_605.release_value(); }));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_607; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_606; {
 if ((open_parens == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::Toplevel((JaktInternal::checked_sub<size_t>(open_parens,static_cast<size_t>(1ULL))),open_curlies,open_squares) } ))));
-__jakt_var_607 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_530;
+__jakt_var_606 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_530;
 
 }
-__jakt_label_530:; __jakt_var_607.release_value(); }));
+__jakt_label_530:; __jakt_var_606.release_value(); }));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_608; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_607; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::Toplevel(open_parens,(JaktInternal::checked_add<size_t>(open_curlies,static_cast<size_t>(1ULL))),open_squares) } ))));
-__jakt_var_608 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_531;
+__jakt_var_607 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_531;
 
 }
-__jakt_label_531:; __jakt_var_608.release_value(); }));
+__jakt_label_531:; __jakt_var_607.release_value(); }));
 };/*case end*/
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_609; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_608; {
 if ((open_curlies == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_sub<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::Toplevel(open_parens,(JaktInternal::checked_sub<size_t>(open_curlies,static_cast<size_t>(1ULL))),open_squares) } ))));
-__jakt_var_609 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_532;
+__jakt_var_608 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_532;
 
 }
-__jakt_label_532:; __jakt_var_609.release_value(); }));
+__jakt_label_532:; __jakt_var_608.release_value(); }));
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_610; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_609; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),true) } ))));
-__jakt_var_610 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_533;
+__jakt_var_609 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_533;
 
 }
-__jakt_label_533:; __jakt_var_610.release_value(); }));
+__jakt_label_533:; __jakt_var_609.release_value(); }));
 };/*case end*/
 case 78: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_611; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_610; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::Import(((((*this).peek(static_cast<i64>(0LL)))).index() == 72 /* Extern */)) } ))));
-__jakt_var_611 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_534;
+__jakt_var_610 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_534;
 
 }
-__jakt_label_534:; __jakt_var_611.release_value(); }));
+__jakt_label_534:; __jakt_var_610.release_value(); }));
 };/*case end*/
 case 90: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -1632,12 +1584,12 @@ case 62: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 case 94: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_612; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_611; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::RestrictionList() } ))));
-__jakt_var_612 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_535;
+__jakt_var_611 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_535;
 
 }
-__jakt_label_535:; __jakt_var_612.release_value(); }));
+__jakt_label_535:; __jakt_var_611.release_value(); }));
 };/*case end*/
 case 52: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -1661,7 +1613,7 @@ case 61: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_613; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_612; {
 if (((!(is_extern)) && ((((*this).peek(static_cast<i64>(0LL)))).index() == 7 /* LParen */))){
 TRY((((*this).push_state( formatter::State { typename formatter::State::StatementContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),JaktInternal::OptionalNone(),false, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,static_cast<size_t>(0ULL)) } ))));
 return (formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -1669,13 +1621,13 @@ return (formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>:
 if (((!(is_extern)) && ((!(((((*this).peek(static_cast<i64>(0LL)))).index() == 9 /* LCurly */))) && (!(((((*this).peek(static_cast<i64>(0LL)))).index() == 61 /* As */)))))){
 ((*this).pop_state());
 }
-__jakt_var_613 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_536;
+__jakt_var_612 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_536;
 
 }
-__jakt_label_536:; __jakt_var_613.release_value(); }));
+__jakt_label_536:; __jakt_var_612.release_value(); }));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_614; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_613; {
 if (is_extern){
 TRY((((*this).push_state( formatter::State { typename formatter::State::Toplevel(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)) } ))));
 }
@@ -1683,22 +1635,22 @@ else {
 TRY((((*this).push_state( formatter::State { typename formatter::State::ImportList(true) } ))));
 }
 
-__jakt_var_614 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_537;
+__jakt_var_613 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_537;
 
 }
-__jakt_label_537:; __jakt_var_614.release_value(); }));
+__jakt_label_537:; __jakt_var_613.release_value(); }));
 };/*case end*/
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_615; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_614; {
 ((*this).pop_state());
-__jakt_var_615 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_538;
+__jakt_var_614 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_538;
 
 }
-__jakt_label_538:; __jakt_var_615.release_value(); }));
+__jakt_label_538:; __jakt_var_614.release_value(); }));
 };/*case end*/
 case 52: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_616; {
-__jakt_var_616 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_615; {
+__jakt_var_615 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -1712,7 +1664,7 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 )),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_539;
 
 }
-__jakt_label_539:; __jakt_var_616.release_value(); }));
+__jakt_label_539:; __jakt_var_615.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -1734,12 +1686,12 @@ return (TRY((((*this).next_impl(true)))));
 }
 };/*case end*/
 case 52: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_617; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_616; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::ImportList(true) } ))));
-__jakt_var_617 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_540;
+__jakt_var_616 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_540;
 
 }
-__jakt_label_540:; __jakt_var_617.release_value(); }));
+__jakt_label_540:; __jakt_var_616.release_value(); }));
 };/*case end*/
 case 55: {
 {
@@ -1747,7 +1699,7 @@ return (TRY((((*this).next()))));
 }
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_618; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_617; {
 JaktInternal::DynamicArray<DeprecatedString> collection = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 DeprecatedString output = Jakt::DeprecatedString(""sv);
 utility::Span const span = ((token).span());
@@ -1832,10 +1784,10 @@ else {
 
 ((*this).pop_state());
 ((((*this).index)--));
-__jakt_var_618 = formatter::FormattedToken( lexer::Token { typename lexer::Token::Identifier(output,span) } ,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_541;
+__jakt_var_617 = formatter::FormattedToken( lexer::Token { typename lexer::Token::Identifier(output,span) } ,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_541;
 
 }
-__jakt_label_541:; __jakt_var_618.release_value(); }));
+__jakt_label_541:; __jakt_var_617.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
@@ -1850,17 +1802,17 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 28: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_619; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_618; {
 if (accept_generics){
 TRY((((*this).replace_state( formatter::State { typename formatter::State::EntityDeclaration(entity,accept_generics,true,(JaktInternal::checked_add<size_t>(generic_nesting,static_cast<size_t>(1ULL)))) } ))));
 }
-__jakt_var_619 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_542;
+__jakt_var_618 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_542;
 
 }
-__jakt_label_542:; __jakt_var_619.release_value(); }));
+__jakt_label_542:; __jakt_var_618.release_value(); }));
 };/*case end*/
 case 26: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_620; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_619; {
 if (accept_generics){
 if ((generic_nesting > static_cast<size_t>(1ULL))){
 TRY((((*this).replace_state( formatter::State { typename formatter::State::EntityDeclaration(entity,accept_generics,has_generics,(JaktInternal::checked_sub<size_t>(generic_nesting,static_cast<size_t>(1ULL)))) } ))));
@@ -1870,39 +1822,39 @@ TRY((((*this).replace_state( formatter::State { typename formatter::State::Entit
 }
 
 }
-__jakt_var_620 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_543;
+__jakt_var_619 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_543;
 
 }
-__jakt_label_543:; __jakt_var_620.release_value(); }));
+__jakt_label_543:; __jakt_var_619.release_value(); }));
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_621; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_620; {
 if (((generic_nesting == static_cast<size_t>(0ULL)) && ((!(((((*this).peek(static_cast<i64>(0LL)))).index() == 28 /* LessThan */))) && (!(has_generics))))){
 TRY((((*this).replace_state( formatter::State { typename formatter::State::EntityDefinition(entity) } ))));
 }
-__jakt_var_621 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_544;
+__jakt_var_620 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_544;
 
 }
-__jakt_label_544:; __jakt_var_621.release_value(); }));
+__jakt_label_544:; __jakt_var_620.release_value(); }));
 };/*case end*/
 case 52: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_622; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_621; {
 ((*this).pop_state());
-__jakt_var_622 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_545;
+__jakt_var_621 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_545;
 
 }
-__jakt_label_545:; __jakt_var_622.release_value(); }));
+__jakt_label_545:; __jakt_var_621.release_value(); }));
 };/*case end*/
 case 55: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_623; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_622; {
 ((*this).pop_state());
-__jakt_var_623 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_546;
+__jakt_var_622 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_546;
 
 }
-__jakt_label_546:; __jakt_var_623.release_value(); }));
+__jakt_label_546:; __jakt_var_622.release_value(); }));
 };/*case end*/
 case 90: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -1917,12 +1869,12 @@ case 88: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 case 94: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_624; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_623; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::RestrictionList() } ))));
-__jakt_var_624 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_547;
+__jakt_var_623 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_547;
 
 }
-__jakt_label_547:; __jakt_var_624.release_value(); }));
+__jakt_label_547:; __jakt_var_623.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -1941,9 +1893,9 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_625; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_624; {
 ((*this).pop_state());
-__jakt_var_625 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_624 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek((-(static_cast<i64>(1LL)))));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -1960,12 +1912,12 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 ))); goto __jakt_label_548;
 
 }
-__jakt_label_548:; __jakt_var_625.release_value(); }));
+__jakt_label_548:; __jakt_var_624.release_value(); }));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_626; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_625; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::Toplevel(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)) } ))));
-__jakt_var_626 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_625 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -1982,7 +1934,7 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 )),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_549;
 
 }
-__jakt_label_549:; __jakt_var_626.release_value(); }));
+__jakt_label_549:; __jakt_var_625.release_value(); }));
 };/*case end*/
 case 5: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -2005,9 +1957,9 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_627; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_626; {
 ((*this).pop_state());
-__jakt_var_627 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_626 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek((-(static_cast<i64>(1LL)))));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -2024,12 +1976,12 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 ))); goto __jakt_label_550;
 
 }
-__jakt_label_550:; __jakt_var_627.release_value(); }));
+__jakt_label_550:; __jakt_var_626.release_value(); }));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_628; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_627; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::Toplevel(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)) } ))));
-__jakt_var_628 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_627 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -2046,7 +1998,7 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 )),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_551;
 
 }
-__jakt_label_551:; __jakt_var_628.release_value(); }));
+__jakt_label_551:; __jakt_var_627.release_value(); }));
 };/*case end*/
 case 5: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -2069,9 +2021,9 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_629; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_628; {
 ((*this).pop_state());
-__jakt_var_629 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_628 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek((-(static_cast<i64>(1LL)))));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -2088,12 +2040,12 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 ))); goto __jakt_label_552;
 
 }
-__jakt_label_552:; __jakt_var_629.release_value(); }));
+__jakt_label_552:; __jakt_var_628.release_value(); }));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_630; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_629; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::Toplevel(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)) } ))));
-__jakt_var_630 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_629 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -2110,7 +2062,7 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 )),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_553;
 
 }
-__jakt_label_553:; __jakt_var_630.release_value(); }));
+__jakt_label_553:; __jakt_var_629.release_value(); }));
 };/*case end*/
 case 5: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -2135,7 +2087,7 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 57: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_631; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_630; {
 bool const next_is_eol = ((((*this).peek(static_cast<i64>(0LL)))).index() == 55 /* Eol */);
 TRY((((*this).replace_state( formatter::State { typename formatter::State::EntityDefinition( formatter::Entity { typename formatter::Entity::Function(true,next_is_eol) } ) } ))));
 if (next_is_eol){
@@ -2151,26 +2103,26 @@ if (next_is_eol){
 (eols_allowed = static_cast<size_t>(1ULL));
 }
 TRY((((*this).push_state( formatter::State { typename formatter::State::StatementContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),eols_allowed,false, formatter::ExpressionMode { typename formatter::ExpressionMode::BeforeExpressions() } ,static_cast<size_t>(0ULL)) } ))));
-__jakt_var_631 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_554;
+__jakt_var_630 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_554;
 
 }
-__jakt_label_554:; __jakt_var_631.release_value(); }));
+__jakt_label_554:; __jakt_var_630.release_value(); }));
 };/*case end*/
 case 58: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_632; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_631; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_632 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_555;
+__jakt_var_631 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_555;
 
 }
-__jakt_label_555:; __jakt_var_632.release_value(); }));
+__jakt_label_555:; __jakt_var_631.release_value(); }));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_633; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_632; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::ParameterList(static_cast<size_t>(0ULL)) } ))));
-__jakt_var_633 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_556;
+__jakt_var_632 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_556;
 
 }
-__jakt_label_556:; __jakt_var_633.release_value(); }));
+__jakt_label_556:; __jakt_var_632.release_value(); }));
 };/*case end*/
 case 8: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
@@ -2187,23 +2139,23 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({})))));
 )),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_634; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_633; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::StatementContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),JaktInternal::OptionalNone(),false, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,static_cast<size_t>(0ULL)) } ))));
-__jakt_var_634 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_557;
+__jakt_var_633 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_557;
 
 }
-__jakt_label_557:; __jakt_var_634.release_value(); }));
+__jakt_label_557:; __jakt_var_633.release_value(); }));
 };/*case end*/
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_635; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_634; {
 ((*this).pop_state());
-__jakt_var_635 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_558;
+__jakt_var_634 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_558;
 
 }
-__jakt_label_558:; __jakt_var_635.release_value(); }));
+__jakt_label_558:; __jakt_var_634.release_value(); }));
 };/*case end*/
 case 55: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_636; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_635; {
 if ((!(arrow))){
 return (TRY((((*this).next()))));
 }
@@ -2219,10 +2171,10 @@ else if (((((((*this).dedents_to_skip)).last()).value()) > static_cast<size_t>(0
 ({auto& _jakt_ref = ((((*this).dedents_to_skip))[(JaktInternal::checked_sub<size_t>(((((*this).dedents_to_skip)).size()),static_cast<size_t>(1ULL)))]);_jakt_ref = JaktInternal::checked_sub<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 }
 }
-__jakt_var_636 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_559;
+__jakt_var_635 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_559;
 
 }
-__jakt_label_559:; __jakt_var_636.release_value(); }));
+__jakt_label_559:; __jakt_var_635.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -2248,84 +2200,84 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 81: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_637; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_636; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
 TRY((((*this).push_state( formatter::State { typename formatter::State::VariableDeclaration(static_cast<size_t>(0ULL)) } ))));
-__jakt_var_637 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_560;
+__jakt_var_636 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_560;
 
 }
-__jakt_label_560:; __jakt_var_637.release_value(); }));
+__jakt_label_560:; __jakt_var_636.release_value(); }));
 };/*case end*/
 case 84: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_638; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_637; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
 if (((expression_mode).index() == 0 /* OutsideExpression */)){
 TRY((((*this).push_state( formatter::State { typename formatter::State::VariableDeclaration(static_cast<size_t>(0ULL)) } ))));
 }
-__jakt_var_638 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_561;
+__jakt_var_637 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_561;
 
 }
-__jakt_label_561:; __jakt_var_638.release_value(); }));
+__jakt_label_561:; __jakt_var_637.release_value(); }));
 };/*case end*/
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_639; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_638; {
 size_t const added_indent = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_640; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_639; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_640 = indent; goto __jakt_label_563;
+__jakt_var_639 = indent; goto __jakt_label_563;
 
 }
-__jakt_label_563:; __jakt_var_640.release_value(); }));
+__jakt_label_563:; __jakt_var_639.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_641; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_640; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_641 = indent; goto __jakt_label_564;
+__jakt_var_640 = indent; goto __jakt_label_564;
 
 }
-__jakt_label_564:; __jakt_var_641.release_value(); }));
+__jakt_label_564:; __jakt_var_640.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_642; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_641; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_642 = indent; goto __jakt_label_565;
+__jakt_var_641 = indent; goto __jakt_label_565;
 
 }
-__jakt_label_565:; __jakt_var_642.release_value(); }));
+__jakt_label_565:; __jakt_var_641.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_643; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_642; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_643 = indent; goto __jakt_label_566;
+__jakt_var_642 = indent; goto __jakt_label_566;
 
 }
-__jakt_label_566:; __jakt_var_643.release_value(); }));
+__jakt_label_566:; __jakt_var_642.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_644; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_643; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_644 = indent; goto __jakt_label_567;
+__jakt_var_643 = indent; goto __jakt_label_567;
 
 }
-__jakt_label_567:; __jakt_var_644.release_value(); }));
+__jakt_label_567:; __jakt_var_643.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
@@ -2335,70 +2287,70 @@ return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
 ));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_add<size_t>(dedents_on_open_curly,added_indent))) } ))));
 ({auto& _jakt_ref = indent_change;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, (infallible_integer_cast<i64>((added_indent))));});
-__jakt_var_639 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_562;
+__jakt_var_638 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_562;
 
 }
-__jakt_label_562:; __jakt_var_639.release_value(); }));
+__jakt_label_562:; __jakt_var_638.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_645; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_644; {
 size_t const added_indent = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_646; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_645; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_646 = indent; goto __jakt_label_569;
+__jakt_var_645 = indent; goto __jakt_label_569;
 
 }
-__jakt_label_569:; __jakt_var_646.release_value(); }));
+__jakt_label_569:; __jakt_var_645.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_647; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_646; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_647 = indent; goto __jakt_label_570;
+__jakt_var_646 = indent; goto __jakt_label_570;
 
 }
-__jakt_label_570:; __jakt_var_647.release_value(); }));
+__jakt_label_570:; __jakt_var_646.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_648; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_647; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_648 = indent; goto __jakt_label_571;
+__jakt_var_647 = indent; goto __jakt_label_571;
 
 }
-__jakt_label_571:; __jakt_var_648.release_value(); }));
+__jakt_label_571:; __jakt_var_647.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_649; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_648; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_649 = indent; goto __jakt_label_572;
+__jakt_var_648 = indent; goto __jakt_label_572;
 
 }
-__jakt_label_572:; __jakt_var_649.release_value(); }));
+__jakt_label_572:; __jakt_var_648.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_650; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_649; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_650 = indent; goto __jakt_label_573;
+__jakt_var_649 = indent; goto __jakt_label_573;
 
 }
-__jakt_label_573:; __jakt_var_650.release_value(); }));
+__jakt_label_573:; __jakt_var_649.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
@@ -2408,70 +2360,70 @@ return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
 ));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_add<size_t>(dedents_on_open_curly,added_indent))) } ))));
 ({auto& _jakt_ref = indent_change;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, (infallible_integer_cast<i64>((added_indent))));});
-__jakt_var_645 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_568;
+__jakt_var_644 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_568;
 
 }
-__jakt_label_568:; __jakt_var_645.release_value(); }));
+__jakt_label_568:; __jakt_var_644.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_651; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_650; {
 size_t const added_indent = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_652; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_651; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_652 = indent; goto __jakt_label_575;
+__jakt_var_651 = indent; goto __jakt_label_575;
 
 }
-__jakt_label_575:; __jakt_var_652.release_value(); }));
+__jakt_label_575:; __jakt_var_651.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_653; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_652; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_653 = indent; goto __jakt_label_576;
+__jakt_var_652 = indent; goto __jakt_label_576;
 
 }
-__jakt_label_576:; __jakt_var_653.release_value(); }));
+__jakt_label_576:; __jakt_var_652.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_654; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_653; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_654 = indent; goto __jakt_label_577;
+__jakt_var_653 = indent; goto __jakt_label_577;
 
 }
-__jakt_label_577:; __jakt_var_654.release_value(); }));
+__jakt_label_577:; __jakt_var_653.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_655; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_654; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_655 = indent; goto __jakt_label_578;
+__jakt_var_654 = indent; goto __jakt_label_578;
 
 }
-__jakt_label_578:; __jakt_var_655.release_value(); }));
+__jakt_label_578:; __jakt_var_654.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_656; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_655; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_656 = indent; goto __jakt_label_579;
+__jakt_var_655 = indent; goto __jakt_label_579;
 
 }
-__jakt_label_579:; __jakt_var_656.release_value(); }));
+__jakt_label_579:; __jakt_var_655.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
@@ -2481,70 +2433,70 @@ return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
 ));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_add<size_t>(dedents_on_open_curly,added_indent))) } ))));
 ({auto& _jakt_ref = indent_change;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, (infallible_integer_cast<i64>((added_indent))));});
-__jakt_var_651 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_574;
+__jakt_var_650 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_574;
 
 }
-__jakt_label_574:; __jakt_var_651.release_value(); }));
+__jakt_label_574:; __jakt_var_650.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_657; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_656; {
 size_t const added_indent = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_658; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_657; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_658 = indent; goto __jakt_label_581;
+__jakt_var_657 = indent; goto __jakt_label_581;
 
 }
-__jakt_label_581:; __jakt_var_658.release_value(); }));
+__jakt_label_581:; __jakt_var_657.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_659; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_658; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_659 = indent; goto __jakt_label_582;
+__jakt_var_658 = indent; goto __jakt_label_582;
 
 }
-__jakt_label_582:; __jakt_var_659.release_value(); }));
+__jakt_label_582:; __jakt_var_658.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_660; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_659; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_660 = indent; goto __jakt_label_583;
+__jakt_var_659 = indent; goto __jakt_label_583;
 
 }
-__jakt_label_583:; __jakt_var_660.release_value(); }));
+__jakt_label_583:; __jakt_var_659.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_661; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_660; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_661 = indent; goto __jakt_label_584;
+__jakt_var_660 = indent; goto __jakt_label_584;
 
 }
-__jakt_label_584:; __jakt_var_661.release_value(); }));
+__jakt_label_584:; __jakt_var_660.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_662; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_661; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_662 = indent; goto __jakt_label_585;
+__jakt_var_661 = indent; goto __jakt_label_585;
 
 }
-__jakt_label_585:; __jakt_var_662.release_value(); }));
+__jakt_label_585:; __jakt_var_661.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
@@ -2554,70 +2506,70 @@ return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
 ));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_add<size_t>(dedents_on_open_curly,added_indent))) } ))));
 ({auto& _jakt_ref = indent_change;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, (infallible_integer_cast<i64>((added_indent))));});
-__jakt_var_657 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_580;
+__jakt_var_656 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_580;
 
 }
-__jakt_label_580:; __jakt_var_657.release_value(); }));
+__jakt_label_580:; __jakt_var_656.release_value(); }));
 };/*case end*/
 case 101: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_663; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_662; {
 size_t const added_indent = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_664; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_663; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_664 = indent; goto __jakt_label_587;
+__jakt_var_663 = indent; goto __jakt_label_587;
 
 }
-__jakt_label_587:; __jakt_var_664.release_value(); }));
+__jakt_label_587:; __jakt_var_663.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_665; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_664; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_665 = indent; goto __jakt_label_588;
+__jakt_var_664 = indent; goto __jakt_label_588;
 
 }
-__jakt_label_588:; __jakt_var_665.release_value(); }));
+__jakt_label_588:; __jakt_var_664.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_666; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_665; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_666 = indent; goto __jakt_label_589;
+__jakt_var_665 = indent; goto __jakt_label_589;
 
 }
-__jakt_label_589:; __jakt_var_666.release_value(); }));
+__jakt_label_589:; __jakt_var_665.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_667; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_666; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_667 = indent; goto __jakt_label_590;
+__jakt_var_666 = indent; goto __jakt_label_590;
 
 }
-__jakt_label_590:; __jakt_var_667.release_value(); }));
+__jakt_label_590:; __jakt_var_666.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_668; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_667; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_668 = indent; goto __jakt_label_591;
+__jakt_var_667 = indent; goto __jakt_label_591;
 
 }
-__jakt_label_591:; __jakt_var_668.release_value(); }));
+__jakt_label_591:; __jakt_var_667.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
@@ -2627,70 +2579,70 @@ return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
 ));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_add<size_t>(dedents_on_open_curly,added_indent))) } ))));
 ({auto& _jakt_ref = indent_change;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, (infallible_integer_cast<i64>((added_indent))));});
-__jakt_var_663 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_586;
+__jakt_var_662 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_586;
 
 }
-__jakt_label_586:; __jakt_var_663.release_value(); }));
+__jakt_label_586:; __jakt_var_662.release_value(); }));
 };/*case end*/
 case 82: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_669; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_668; {
 size_t const added_indent = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_670; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_669; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_670 = indent; goto __jakt_label_593;
+__jakt_var_669 = indent; goto __jakt_label_593;
 
 }
-__jakt_label_593:; __jakt_var_670.release_value(); }));
+__jakt_label_593:; __jakt_var_669.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_671; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_670; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_671 = indent; goto __jakt_label_594;
+__jakt_var_670 = indent; goto __jakt_label_594;
 
 }
-__jakt_label_594:; __jakt_var_671.release_value(); }));
+__jakt_label_594:; __jakt_var_670.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_672; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_671; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_672 = indent; goto __jakt_label_595;
+__jakt_var_671 = indent; goto __jakt_label_595;
 
 }
-__jakt_label_595:; __jakt_var_672.release_value(); }));
+__jakt_label_595:; __jakt_var_671.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_673; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_672; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_673 = indent; goto __jakt_label_596;
+__jakt_var_672 = indent; goto __jakt_label_596;
 
 }
-__jakt_label_596:; __jakt_var_673.release_value(); }));
+__jakt_label_596:; __jakt_var_672.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_674; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_673; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_674 = indent; goto __jakt_label_597;
+__jakt_var_673 = indent; goto __jakt_label_597;
 
 }
-__jakt_label_597:; __jakt_var_674.release_value(); }));
+__jakt_label_597:; __jakt_var_673.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
@@ -2700,70 +2652,70 @@ return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
 ));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_add<size_t>(dedents_on_open_curly,added_indent))) } ))));
 ({auto& _jakt_ref = indent_change;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, (infallible_integer_cast<i64>((added_indent))));});
-__jakt_var_669 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_592;
+__jakt_var_668 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_592;
 
 }
-__jakt_label_592:; __jakt_var_669.release_value(); }));
+__jakt_label_592:; __jakt_var_668.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_675; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_674; {
 size_t const added_indent = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_676; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_675; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_676 = indent; goto __jakt_label_599;
+__jakt_var_675 = indent; goto __jakt_label_599;
 
 }
-__jakt_label_599:; __jakt_var_676.release_value(); }));
+__jakt_label_599:; __jakt_var_675.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_677; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_676; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_677 = indent; goto __jakt_label_600;
+__jakt_var_676 = indent; goto __jakt_label_600;
 
 }
-__jakt_label_600:; __jakt_var_677.release_value(); }));
+__jakt_label_600:; __jakt_var_676.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_678; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_677; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_678 = indent; goto __jakt_label_601;
+__jakt_var_677 = indent; goto __jakt_label_601;
 
 }
-__jakt_label_601:; __jakt_var_678.release_value(); }));
+__jakt_label_601:; __jakt_var_677.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_679; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_678; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_679 = indent; goto __jakt_label_602;
+__jakt_var_678 = indent; goto __jakt_label_602;
 
 }
-__jakt_label_602:; __jakt_var_679.release_value(); }));
+__jakt_label_602:; __jakt_var_678.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_680; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_679; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_680 = indent; goto __jakt_label_603;
+__jakt_var_679 = indent; goto __jakt_label_603;
 
 }
-__jakt_label_603:; __jakt_var_680.release_value(); }));
+__jakt_label_603:; __jakt_var_679.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
@@ -2773,70 +2725,70 @@ return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
 ));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_add<size_t>(dedents_on_open_curly,added_indent))) } ))));
 ({auto& _jakt_ref = indent_change;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, (infallible_integer_cast<i64>((added_indent))));});
-__jakt_var_675 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_598;
+__jakt_var_674 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_598;
 
 }
-__jakt_label_598:; __jakt_var_675.release_value(); }));
+__jakt_label_598:; __jakt_var_674.release_value(); }));
 };/*case end*/
 case 68: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_681; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_680; {
 size_t const added_indent = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 83: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_682; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_681; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_682 = indent; goto __jakt_label_605;
+__jakt_var_681 = indent; goto __jakt_label_605;
 
 }
-__jakt_label_605:; __jakt_var_682.release_value(); }));
+__jakt_label_605:; __jakt_var_681.release_value(); }));
 };/*case end*/
 case 74: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_683; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_682; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_683 = indent; goto __jakt_label_606;
+__jakt_var_682 = indent; goto __jakt_label_606;
 
 }
-__jakt_label_606:; __jakt_var_683.release_value(); }));
+__jakt_label_606:; __jakt_var_682.release_value(); }));
 };/*case end*/
 case 105: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_684; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_683; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_684 = indent; goto __jakt_label_607;
+__jakt_var_683 = indent; goto __jakt_label_607;
 
 }
-__jakt_label_607:; __jakt_var_684.release_value(); }));
+__jakt_label_607:; __jakt_var_683.release_value(); }));
 };/*case end*/
 case 77: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_685; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_684; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_685 = indent; goto __jakt_label_608;
+__jakt_var_684 = indent; goto __jakt_label_608;
 
 }
-__jakt_label_608:; __jakt_var_685.release_value(); }));
+__jakt_label_608:; __jakt_var_684.release_value(); }));
 };/*case end*/
 case 107: {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_686; {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_685; {
 size_t indent = static_cast<size_t>(1ULL);
 if (((*this).line_has_indent())){
 (indent = static_cast<size_t>(0ULL));
 }
-__jakt_var_686 = indent; goto __jakt_label_609;
+__jakt_var_685 = indent; goto __jakt_label_609;
 
 }
-__jakt_label_609:; __jakt_var_686.release_value(); }));
+__jakt_label_609:; __jakt_var_685.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
@@ -2846,15 +2798,15 @@ return JaktInternal::ExplicitValue(static_cast<size_t>(0ULL));
 ));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_add<size_t>(dedents_on_open_curly,added_indent))) } ))));
 ({auto& _jakt_ref = indent_change;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, (infallible_integer_cast<i64>((added_indent))));});
-__jakt_var_681 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_604;
+__jakt_var_680 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_604;
 
 }
-__jakt_label_604:; __jakt_var_681.release_value(); }));
+__jakt_label_604:; __jakt_var_680.release_value(); }));
 };/*case end*/
 case 64: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_687; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_686; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_687 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_686 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -2888,12 +2840,12 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 ))); goto __jakt_label_610;
 
 }
-__jakt_label_610:; __jakt_var_687.release_value(); }));
+__jakt_label_610:; __jakt_var_686.release_value(); }));
 };/*case end*/
 case 70: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_688; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_687; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_688 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_687 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -2927,10 +2879,10 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 ))); goto __jakt_label_611;
 
 }
-__jakt_label_611:; __jakt_var_688.release_value(); }));
+__jakt_label_611:; __jakt_var_687.release_value(); }));
 };/*case end*/
 case 55: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_689; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_688; {
 if ((((expression_mode).index() == 1 /* BeforeExpressions */) && ((((*this).peek(static_cast<i64>(0LL)))).index() == 55 /* Eol */))){
 return (TRY((((*this).next()))));
 }
@@ -2964,23 +2916,23 @@ else if (((((((*this).dedents_to_skip)).last()).value()) > static_cast<size_t>(0
 }
 
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,new_arrow_indents,new_allow_eol,inserted_comma,new_expression_mode,dedents_on_open_curly) } ))));
-__jakt_var_689 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_612;
+__jakt_var_688 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_612;
 
 }
-__jakt_label_612:; __jakt_var_689.release_value(); }));
+__jakt_label_612:; __jakt_var_688.release_value(); }));
 };/*case end*/
 case 75: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_690; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_689; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::FunctionTypeContext(false) } ))));
-__jakt_var_690 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_613;
+__jakt_var_689 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_613;
 
 }
-__jakt_label_613:; __jakt_var_690.release_value(); }));
+__jakt_label_613:; __jakt_var_689.release_value(); }));
 };/*case end*/
 case 52: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<formatter::FormattedToken>> __jakt_var_691; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<formatter::FormattedToken>> __jakt_var_690; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_691 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<formatter::FormattedToken>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_690 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<formatter::FormattedToken>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -2994,35 +2946,35 @@ return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).inde
 )); goto __jakt_label_614;
 
 }
-__jakt_label_614:; __jakt_var_691.release_value(); }));
+__jakt_label_614:; __jakt_var_690.release_value(); }));
 };/*case end*/
 case 93: {
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<formatter::FormattedToken>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 4: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_692; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_691; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_692 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_615;
+__jakt_var_691 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_615;
 
 }
-__jakt_label_615:; __jakt_var_692.release_value(); }));
+__jakt_label_615:; __jakt_var_691.release_value(); }));
 };/*case end*/
 case 55: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_693; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_692; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_693 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_616;
+__jakt_var_692 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_616;
 
 }
-__jakt_label_616:; __jakt_var_693.release_value(); }));
+__jakt_label_616:; __jakt_var_692.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_694; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_693; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_694 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_617;
+__jakt_var_693 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_617;
 
 }
-__jakt_label_617:; __jakt_var_694.release_value(); }));
+__jakt_label_617:; __jakt_var_693.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
@@ -3033,28 +2985,28 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 4: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_695; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_694; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_695 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_618;
+__jakt_var_694 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_618;
 
 }
-__jakt_label_618:; __jakt_var_695.release_value(); }));
+__jakt_label_618:; __jakt_var_694.release_value(); }));
 };/*case end*/
 case 55: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_696; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_695; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_696 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_619;
+__jakt_var_695 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_619;
 
 }
-__jakt_label_619:; __jakt_var_696.release_value(); }));
+__jakt_label_619:; __jakt_var_695.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_697; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_696; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_697 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_620;
+__jakt_var_696 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_620;
 
 }
-__jakt_label_620:; __jakt_var_697.release_value(); }));
+__jakt_label_620:; __jakt_var_696.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
@@ -3065,35 +3017,35 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 4: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_698; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_697; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_698 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_621;
+__jakt_var_697 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_621;
 
 }
-__jakt_label_621:; __jakt_var_698.release_value(); }));
+__jakt_label_621:; __jakt_var_697.release_value(); }));
 };/*case end*/
 case 55: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_699; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_698; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_699 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_622;
+__jakt_var_698 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_622;
 
 }
-__jakt_label_622:; __jakt_var_699.release_value(); }));
+__jakt_label_622:; __jakt_var_698.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_700; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_699; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_700 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_623;
+__jakt_var_699 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_623;
 
 }
-__jakt_label_623:; __jakt_var_700.release_value(); }));
+__jakt_label_623:; __jakt_var_699.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
 case 57: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_701; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_700; {
 bool const next_is_eol = ((((*this).peek(static_cast<i64>(0LL)))).index() == 55 /* Eol */);
 size_t new_arrow_indents = arrow_indents;
 if (next_is_eol){
@@ -3117,62 +3069,62 @@ return JaktInternal::ExplicitValue( formatter::ExpressionMode { typename formatt
 }/*switch end*/
 }()
 )),dedents_on_open_curly) } ))));
-__jakt_var_701 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_624;
+__jakt_var_700 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_624;
 
 }
-__jakt_label_624:; __jakt_var_701.release_value(); }));
+__jakt_label_624:; __jakt_var_700.release_value(); }));
 };/*case end*/
 case 11: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_702; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_701; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,(JaktInternal::checked_add<size_t>(open_squares,static_cast<size_t>(1ULL))),arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_702 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_625;
+__jakt_var_701 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_625;
 
 }
-__jakt_label_625:; __jakt_var_702.release_value(); }));
+__jakt_label_625:; __jakt_var_701.release_value(); }));
 };/*case end*/
 case 12: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_703; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_702; {
 if ((open_squares == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,(JaktInternal::checked_sub<size_t>(open_squares,static_cast<size_t>(1ULL))),arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_703 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_626;
+__jakt_var_702 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_626;
 
 }
-__jakt_label_626:; __jakt_var_703.release_value(); }));
+__jakt_label_626:; __jakt_var_702.release_value(); }));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_704; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_703; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext((JaktInternal::checked_add<size_t>(open_parens,static_cast<size_t>(1ULL))),open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_704 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_627;
+__jakt_var_703 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_627;
 
 }
-__jakt_label_627:; __jakt_var_704.release_value(); }));
+__jakt_label_627:; __jakt_var_703.release_value(); }));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_705; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_704; {
 if ((open_parens == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext((JaktInternal::checked_sub<size_t>(open_parens,static_cast<size_t>(1ULL))),open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::InExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_705 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_628;
+__jakt_var_704 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_628;
 
 }
-__jakt_label_628:; __jakt_var_705.release_value(); }));
+__jakt_label_628:; __jakt_var_704.release_value(); }));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_706; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_705; {
 size_t dedented = static_cast<size_t>(0ULL);
 if ((dedents_on_open_curly > static_cast<size_t>(0ULL))){
 ({auto& _jakt_ref = ((*this).indent);_jakt_ref = JaktInternal::checked_sub<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 (dedented = static_cast<size_t>(1ULL));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,(JaktInternal::checked_add<size_t>(open_curlies,static_cast<size_t>(1ULL))),open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,(JaktInternal::checked_sub<size_t>(dedents_on_open_curly,dedented))) } ))));
-__jakt_var_706 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_705 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = expression_mode;
 switch(__jakt_match_variant.index()) {
 case 2: {
@@ -3232,17 +3184,17 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 ))); goto __jakt_label_629;
 
 }
-__jakt_label_629:; __jakt_var_706.release_value(); }));
+__jakt_label_629:; __jakt_var_705.release_value(); }));
 };/*case end*/
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_707; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_706; {
 if ((open_curlies == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_sub<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,(JaktInternal::checked_sub<size_t>(open_curlies,static_cast<size_t>(1ULL))),open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::InExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_707 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_706 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek((-(static_cast<i64>(1LL)))));
 switch(__jakt_match_variant.index()) {
 case 55: {
@@ -3259,20 +3211,20 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 ))); goto __jakt_label_630;
 
 }
-__jakt_label_630:; __jakt_var_707.release_value(); }));
+__jakt_label_630:; __jakt_var_706.release_value(); }));
 };/*case end*/
 case 86: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_708; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_707; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_708 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_631;
+__jakt_var_707 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_631;
 
 }
-__jakt_label_631:; __jakt_var_708.release_value(); }));
+__jakt_label_631:; __jakt_var_707.release_value(); }));
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_709; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_708; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_709 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_708 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 12: {
@@ -3286,10 +3238,10 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({' '}))))
 )),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_632;
 
 }
-__jakt_label_632:; __jakt_var_709.release_value(); }));
+__jakt_label_632:; __jakt_var_708.release_value(); }));
 };/*case end*/
 case 15: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_710; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_709; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
 JaktInternal::DynamicArray<u8> const trivia = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = expression_mode;
@@ -3303,13 +3255,13 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({})))));
 }/*switch end*/
 }()
 ));
-__jakt_var_710 = formatter::FormattedToken(token,((*this).indent),trivia,trivia); goto __jakt_label_633;
+__jakt_var_709 = formatter::FormattedToken(token,((*this).indent),trivia,trivia); goto __jakt_label_633;
 
 }
-__jakt_label_633:; __jakt_var_710.release_value(); }));
+__jakt_label_633:; __jakt_var_709.release_value(); }));
 };/*case end*/
 case 36: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_711; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_710; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
 JaktInternal::DynamicArray<u8> const trivia = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = expression_mode;
@@ -3323,13 +3275,13 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({})))));
 }/*switch end*/
 }()
 ));
-__jakt_var_711 = formatter::FormattedToken(token,((*this).indent),trivia,trivia); goto __jakt_label_634;
+__jakt_var_710 = formatter::FormattedToken(token,((*this).indent),trivia,trivia); goto __jakt_label_634;
 
 }
-__jakt_label_634:; __jakt_var_711.release_value(); }));
+__jakt_label_634:; __jakt_var_710.release_value(); }));
 };/*case end*/
 case 37: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_712; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_711; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
 JaktInternal::DynamicArray<u8> const trivia = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = expression_mode;
@@ -3343,266 +3295,266 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({})))));
 }/*switch end*/
 }()
 ));
-__jakt_var_712 = formatter::FormattedToken(token,((*this).indent),trivia,trivia); goto __jakt_label_635;
+__jakt_var_711 = formatter::FormattedToken(token,((*this).indent),trivia,trivia); goto __jakt_label_635;
 
 }
-__jakt_label_635:; __jakt_var_712.release_value(); }));
+__jakt_label_635:; __jakt_var_711.release_value(); }));
 };/*case end*/
 case 13: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_713; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_712; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_713 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_636;
+__jakt_var_712 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_636;
 
 }
-__jakt_label_636:; __jakt_var_713.release_value(); }));
+__jakt_label_636:; __jakt_var_712.release_value(); }));
 };/*case end*/
 case 14: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_714; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_713; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_714 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_637;
+__jakt_var_713 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_637;
 
 }
-__jakt_label_637:; __jakt_var_714.release_value(); }));
+__jakt_label_637:; __jakt_var_713.release_value(); }));
 };/*case end*/
 case 16: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_715; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_714; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_715 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_638;
+__jakt_var_714 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_638;
 
 }
-__jakt_label_638:; __jakt_var_715.release_value(); }));
+__jakt_label_638:; __jakt_var_714.release_value(); }));
 };/*case end*/
 case 40: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_716; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_715; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_716 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_639;
+__jakt_var_715 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_639;
 
 }
-__jakt_label_639:; __jakt_var_716.release_value(); }));
+__jakt_label_639:; __jakt_var_715.release_value(); }));
 };/*case end*/
 case 17: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_717; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_716; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_717 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_640;
+__jakt_var_716 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_640;
 
 }
-__jakt_label_640:; __jakt_var_717.release_value(); }));
+__jakt_label_640:; __jakt_var_716.release_value(); }));
 };/*case end*/
 case 19: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_718; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_717; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_718 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_641;
+__jakt_var_717 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_641;
 
 }
-__jakt_label_641:; __jakt_var_718.release_value(); }));
+__jakt_label_641:; __jakt_var_717.release_value(); }));
 };/*case end*/
 case 21: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_719; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_718; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_719 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_642;
+__jakt_var_718 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_642;
 
 }
-__jakt_label_642:; __jakt_var_719.release_value(); }));
+__jakt_label_642:; __jakt_var_718.release_value(); }));
 };/*case end*/
 case 22: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_720; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_719; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_720 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_643;
+__jakt_var_719 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_643;
 
 }
-__jakt_label_643:; __jakt_var_720.release_value(); }));
+__jakt_label_643:; __jakt_var_719.release_value(); }));
 };/*case end*/
 case 23: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_721; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_720; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_721 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_644;
+__jakt_var_720 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_644;
 
 }
-__jakt_label_644:; __jakt_var_721.release_value(); }));
+__jakt_label_644:; __jakt_var_720.release_value(); }));
 };/*case end*/
 case 24: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_722; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_721; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_722 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_645;
+__jakt_var_721 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_645;
 
 }
-__jakt_label_645:; __jakt_var_722.release_value(); }));
+__jakt_label_645:; __jakt_var_721.release_value(); }));
 };/*case end*/
 case 25: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_723; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_722; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_723 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_646;
+__jakt_var_722 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_646;
 
 }
-__jakt_label_646:; __jakt_var_723.release_value(); }));
+__jakt_label_646:; __jakt_var_722.release_value(); }));
 };/*case end*/
 case 26: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_724; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_723; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_724 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_647;
+__jakt_var_723 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_647;
 
 }
-__jakt_label_647:; __jakt_var_724.release_value(); }));
+__jakt_label_647:; __jakt_var_723.release_value(); }));
 };/*case end*/
 case 27: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_725; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_724; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_725 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_648;
+__jakt_var_724 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_648;
 
 }
-__jakt_label_648:; __jakt_var_725.release_value(); }));
+__jakt_label_648:; __jakt_var_724.release_value(); }));
 };/*case end*/
 case 28: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_726; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_725; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_726 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_649;
+__jakt_var_725 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_649;
 
 }
-__jakt_label_649:; __jakt_var_726.release_value(); }));
+__jakt_label_649:; __jakt_var_725.release_value(); }));
 };/*case end*/
 case 29: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_727; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_726; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_727 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_650;
+__jakt_var_726 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_650;
 
 }
-__jakt_label_650:; __jakt_var_727.release_value(); }));
+__jakt_label_650:; __jakt_var_726.release_value(); }));
 };/*case end*/
 case 30: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_728; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_727; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_728 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_651;
+__jakt_var_727 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_651;
 
 }
-__jakt_label_651:; __jakt_var_728.release_value(); }));
+__jakt_label_651:; __jakt_var_727.release_value(); }));
 };/*case end*/
 case 31: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_729; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_728; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_729 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_652;
+__jakt_var_728 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_652;
 
 }
-__jakt_label_652:; __jakt_var_729.release_value(); }));
+__jakt_label_652:; __jakt_var_728.release_value(); }));
 };/*case end*/
 case 33: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_730; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_729; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_730 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_653;
+__jakt_var_729 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_653;
 
 }
-__jakt_label_653:; __jakt_var_730.release_value(); }));
+__jakt_label_653:; __jakt_var_729.release_value(); }));
 };/*case end*/
 case 32: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_731; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_730; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_731 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_654;
+__jakt_var_730 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_654;
 
 }
-__jakt_label_654:; __jakt_var_731.release_value(); }));
+__jakt_label_654:; __jakt_var_730.release_value(); }));
 };/*case end*/
 case 34: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_732; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_731; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_732 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_655;
+__jakt_var_731 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_655;
 
 }
-__jakt_label_655:; __jakt_var_732.release_value(); }));
+__jakt_label_655:; __jakt_var_731.release_value(); }));
 };/*case end*/
 case 35: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_733; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_732; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_733 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_656;
+__jakt_var_732 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_656;
 
 }
-__jakt_label_656:; __jakt_var_733.release_value(); }));
+__jakt_label_656:; __jakt_var_732.release_value(); }));
 };/*case end*/
 case 38: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_734; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_733; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_734 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_657;
+__jakt_var_733 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_657;
 
 }
-__jakt_label_657:; __jakt_var_734.release_value(); }));
+__jakt_label_657:; __jakt_var_733.release_value(); }));
 };/*case end*/
 case 41: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_735; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_734; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_735 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_658;
+__jakt_var_734 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_658;
 
 }
-__jakt_label_658:; __jakt_var_735.release_value(); }));
+__jakt_label_658:; __jakt_var_734.release_value(); }));
 };/*case end*/
 case 43: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_736; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_735; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_736 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_659;
+__jakt_var_735 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_659;
 
 }
-__jakt_label_659:; __jakt_var_736.release_value(); }));
+__jakt_label_659:; __jakt_var_735.release_value(); }));
 };/*case end*/
 case 44: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_737; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_736; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_737 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_660;
+__jakt_var_736 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_660;
 
 }
-__jakt_label_660:; __jakt_var_737.release_value(); }));
+__jakt_label_660:; __jakt_var_736.release_value(); }));
 };/*case end*/
 case 47: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_738; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_737; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_738 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_661;
+__jakt_var_737 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_661;
 
 }
-__jakt_label_661:; __jakt_var_738.release_value(); }));
+__jakt_label_661:; __jakt_var_737.release_value(); }));
 };/*case end*/
 case 50: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_739; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_738; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_739 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_662;
+__jakt_var_738 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_662;
 
 }
-__jakt_label_662:; __jakt_var_739.release_value(); }));
+__jakt_label_662:; __jakt_var_738.release_value(); }));
 };/*case end*/
 case 51: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_740; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_739; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_740 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_663;
+__jakt_var_739 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_663;
 
 }
-__jakt_label_663:; __jakt_var_740.release_value(); }));
+__jakt_label_663:; __jakt_var_739.release_value(); }));
 };/*case end*/
 case 59: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_741; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_740; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_741 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_664;
+__jakt_var_740 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_664;
 
 }
-__jakt_label_664:; __jakt_var_741.release_value(); }));
+__jakt_label_664:; __jakt_var_740.release_value(); }));
 };/*case end*/
 case 79: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_742; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_741; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_742 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_665;
+__jakt_var_741 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_665;
 
 }
-__jakt_label_665:; __jakt_var_742.release_value(); }));
+__jakt_label_665:; __jakt_var_741.release_value(); }));
 };/*case end*/
 case 87: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_743; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_742; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_743 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_666;
+__jakt_var_742 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_666;
 
 }
-__jakt_label_666:; __jakt_var_743.release_value(); }));
+__jakt_label_666:; __jakt_var_742.release_value(); }));
 };/*case end*/
 case 80: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_744; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_743; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::MatchPattern(static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_744 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_667;
+__jakt_var_743 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_667;
 
 }
-__jakt_label_667:; __jakt_var_744.release_value(); }));
+__jakt_label_667:; __jakt_var_743.release_value(); }));
 };/*case end*/
 case 61: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
@@ -3626,11 +3578,11 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = ((*this).peek((-(static_cast<i64>(1LL)))));
 switch(__jakt_match_variant.index()) {
 case 61: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_745; {
-__jakt_var_745 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_668;
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_744; {
+__jakt_var_744 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_668;
 
 }
-__jakt_label_668:; __jakt_var_745.release_value(); }));
+__jakt_label_668:; __jakt_var_744.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -3644,11 +3596,11 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = ((*this).peek((-(static_cast<i64>(1LL)))));
 switch(__jakt_match_variant.index()) {
 case 61: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_746; {
-__jakt_var_746 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_669;
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_745; {
+__jakt_var_745 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_669;
 
 }
-__jakt_label_669:; __jakt_var_746.release_value(); }));
+__jakt_label_669:; __jakt_var_745.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -3658,7 +3610,7 @@ return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).inde
 )));
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_747; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_746; {
 if ((((((*this).peek((-(static_cast<i64>(1LL)))))).index() == 3 /* Identifier */) && (!(inserted_comma)))){
 ((((*this).index)--));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,true, formatter::ExpressionMode { typename formatter::ExpressionMode::InExpression() } ,dedents_on_open_curly) } ))));
@@ -3899,13 +3851,13 @@ return JaktInternal::ExplicitValue<void>();
 if (((open_angles == static_cast<i64>(0LL)) && ((((*this).peek(lookahead_index))).index() == 7 /* LParen */))){
 TRY((((*this).push_state( formatter::State { typename formatter::State::GenericCallTypeParams(static_cast<size_t>(0ULL)) } ))));
 }
-__jakt_var_747 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_670;
+__jakt_var_746 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_670;
 
 }
-__jakt_label_670:; __jakt_var_747.release_value(); }));
+__jakt_label_670:; __jakt_var_746.release_value(); }));
 };/*case end*/
 case 2: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_748; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_747; {
 if ((((((*this).peek((-(static_cast<i64>(1LL)))))).index() == 3 /* Identifier */) && (!(inserted_comma)))){
 ((((*this).index)--));
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,true, formatter::ExpressionMode { typename formatter::ExpressionMode::InExpression() } ,dedents_on_open_curly) } ))));
@@ -4146,13 +4098,13 @@ return JaktInternal::ExplicitValue<void>();
 if (((open_angles == static_cast<i64>(0LL)) && ((((*this).peek(lookahead_index))).index() == 7 /* LParen */))){
 TRY((((*this).push_state( formatter::State { typename formatter::State::GenericCallTypeParams(static_cast<size_t>(0ULL)) } ))));
 }
-__jakt_var_748 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_671;
+__jakt_var_747 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_671;
 
 }
-__jakt_label_671:; __jakt_var_748.release_value(); }));
+__jakt_label_671:; __jakt_var_747.release_value(); }));
 };/*case end*/
 case 4: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_749; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_748; {
 if ((open_squares == static_cast<size_t>(0ULL))){
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<formatter::FormattedToken>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
@@ -4167,26 +4119,26 @@ return JaktInternal::ExplicitValue(formatter::FormattedToken( lexer::Token { typ
 }()
 )));
 }
-__jakt_var_749 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_672;
+__jakt_var_748 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_672;
 
 }
-__jakt_label_672:; __jakt_var_749.release_value(); }));
+__jakt_label_672:; __jakt_var_748.release_value(); }));
 };/*case end*/
 case 91: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_750; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_749; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,dedents_on_open_curly) } ))));
-__jakt_var_750 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_673;
+__jakt_var_749 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_673;
 
 }
-__jakt_label_673:; __jakt_var_750.release_value(); }));
+__jakt_label_673:; __jakt_var_749.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_751; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_750; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::StatementContext(open_parens,open_curlies,open_squares,arrow_indents,allow_eol,inserted_comma, formatter::ExpressionMode { typename formatter::ExpressionMode::InExpression() } ,dedents_on_open_curly) } ))));
-__jakt_var_751 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_674;
+__jakt_var_750 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_674;
 
 }
-__jakt_label_674:; __jakt_var_751.release_value(); }));
+__jakt_label_674:; __jakt_var_750.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
@@ -4198,15 +4150,15 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 28: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_752; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_751; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_752 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_675;
+__jakt_var_751 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_675;
 
 }
-__jakt_label_675:; __jakt_var_752.release_value(); }));
+__jakt_label_675:; __jakt_var_751.release_value(); }));
 };/*case end*/
 case 26: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_753; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_752; {
 if ((open_angles <= static_cast<size_t>(1ULL))){
 ((*this).pop_state());
 }
@@ -4214,18 +4166,18 @@ else {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::GenericCallTypeParams((JaktInternal::checked_sub<size_t>(open_angles,static_cast<size_t>(1ULL)))) } ))));
 }
 
-__jakt_var_753 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_676;
+__jakt_var_752 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_676;
 
 }
-__jakt_label_676:; __jakt_var_753.release_value(); }));
+__jakt_label_676:; __jakt_var_752.release_value(); }));
 };/*case end*/
 case 52: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_754; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_753; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_754 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_677;
+__jakt_var_753 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_677;
 
 }
-__jakt_label_677:; __jakt_var_754.release_value(); }));
+__jakt_label_677:; __jakt_var_753.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -4240,41 +4192,41 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 5: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_755; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_754; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_755 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_678;
+__jakt_var_754 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_678;
 
 }
-__jakt_label_678:; __jakt_var_755.release_value(); }));
+__jakt_label_678:; __jakt_var_754.release_value(); }));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_756; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_755; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::VariableDeclaration((JaktInternal::checked_add<size_t>(open_parens,static_cast<size_t>(1ULL)))) } ))));
-__jakt_var_756 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_679;
+__jakt_var_755 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_679;
 
 }
-__jakt_label_679:; __jakt_var_756.release_value(); }));
+__jakt_label_679:; __jakt_var_755.release_value(); }));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_757; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_756; {
 if ((open_parens == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::VariableDeclaration((JaktInternal::checked_sub<size_t>(open_parens,static_cast<size_t>(1ULL)))) } ))));
-__jakt_var_757 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_680;
+__jakt_var_756 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_680;
 
 }
-__jakt_label_680:; __jakt_var_757.release_value(); }));
+__jakt_label_680:; __jakt_var_756.release_value(); }));
 };/*case end*/
 case 16: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_758; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_757; {
 ((*this).pop_state());
-__jakt_var_758 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_681;
+__jakt_var_757 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_681;
 
 }
-__jakt_label_681:; __jakt_var_758.release_value(); }));
+__jakt_label_681:; __jakt_var_757.release_value(); }));
 };/*case end*/
 case 52: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -4291,20 +4243,20 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 52: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_759; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_758; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_759 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_682;
+__jakt_var_758 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_682;
 
 }
-__jakt_label_682:; __jakt_var_759.release_value(); }));
+__jakt_label_682:; __jakt_var_758.release_value(); }));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_760; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_759; {
 ((*this).pop_state());
-__jakt_var_760 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_683;
+__jakt_var_759 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_683;
 
 }
-__jakt_label_683:; __jakt_var_760.release_value(); }));
+__jakt_label_683:; __jakt_var_759.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -4325,44 +4277,44 @@ case 84: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_761; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_760; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_761 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_684;
+__jakt_var_760 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_684;
 
 }
-__jakt_label_684:; __jakt_var_761.release_value(); }));
+__jakt_label_684:; __jakt_var_760.release_value(); }));
 };/*case end*/
 case 52: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 case 16: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_762; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_761; {
 TRY((((*this).push_state( formatter::State { typename formatter::State::StatementContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false, formatter::ExpressionMode { typename formatter::ExpressionMode::AtExpressionStart() } ,static_cast<size_t>(0ULL)) } ))));
-__jakt_var_762 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_685;
+__jakt_var_761 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_685;
 
 }
-__jakt_label_685:; __jakt_var_762.release_value(); }));
+__jakt_label_685:; __jakt_var_761.release_value(); }));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_763; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_762; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::ParameterList((JaktInternal::checked_add<size_t>(open_parens,static_cast<size_t>(1ULL)))) } ))));
-__jakt_var_763 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_686;
+__jakt_var_762 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_686;
 
 }
-__jakt_label_686:; __jakt_var_763.release_value(); }));
+__jakt_label_686:; __jakt_var_762.release_value(); }));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_764; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_763; {
 if ((open_parens == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::ParameterList((JaktInternal::checked_sub<size_t>(open_parens,static_cast<size_t>(1ULL)))) } ))));
-__jakt_var_764 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_687;
+__jakt_var_763 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_687;
 
 }
-__jakt_label_687:; __jakt_var_764.release_value(); }));
+__jakt_label_687:; __jakt_var_763.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
@@ -4381,40 +4333,40 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 28: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_765; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_764; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,open_squares,(JaktInternal::checked_add<size_t>(open_angles,static_cast<size_t>(1ULL))),seen_start) } ))));
-__jakt_var_765 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_688;
+__jakt_var_764 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_688;
 
 }
-__jakt_label_688:; __jakt_var_765.release_value(); }));
+__jakt_label_688:; __jakt_var_764.release_value(); }));
 };/*case end*/
 case 26: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_766; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_765; {
 if ((open_angles == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,open_squares,(JaktInternal::checked_sub<size_t>(open_angles,static_cast<size_t>(1ULL))),seen_start) } ))));
-__jakt_var_766 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_689;
+__jakt_var_765 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_689;
 
 }
-__jakt_label_689:; __jakt_var_766.release_value(); }));
+__jakt_label_689:; __jakt_var_765.release_value(); }));
 };/*case end*/
 case 55: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_767; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_766; {
 if (((JaktInternal::checked_add<size_t>((JaktInternal::checked_add<size_t>((JaktInternal::checked_add<size_t>(open_parens,open_curlies)),open_squares)),open_angles)) == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
-__jakt_var_767 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_690;
+__jakt_var_766 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_690;
 
 }
-__jakt_label_690:; __jakt_var_767.release_value(); }));
+__jakt_label_690:; __jakt_var_766.release_value(); }));
 };/*case end*/
 case 11: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_768; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_767; {
 if (seen_start){
 ((((*this).index)--));
 ((*this).pop_state());
@@ -4422,26 +4374,26 @@ return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,(JaktInternal::checked_add<size_t>(open_squares,static_cast<size_t>(1ULL))),open_angles,true) } ))));
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_768 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_691;
+__jakt_var_767 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_691;
 
 }
-__jakt_label_691:; __jakt_var_768.release_value(); }));
+__jakt_label_691:; __jakt_var_767.release_value(); }));
 };/*case end*/
 case 12: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_769; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_768; {
 if ((open_squares == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,(JaktInternal::checked_sub<size_t>(open_squares,static_cast<size_t>(1ULL))),open_angles,seen_start) } ))));
-__jakt_var_769 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_692;
+__jakt_var_768 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_692;
 
 }
-__jakt_label_692:; __jakt_var_769.release_value(); }));
+__jakt_label_692:; __jakt_var_768.release_value(); }));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_770; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_769; {
 if (seen_start){
 ((((*this).index)--));
 ((*this).pop_state());
@@ -4449,26 +4401,26 @@ return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext((JaktInternal::checked_add<size_t>(open_parens,static_cast<size_t>(1ULL))),open_curlies,open_squares,open_angles,true) } ))));
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_770 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_693;
+__jakt_var_769 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_693;
 
 }
-__jakt_label_693:; __jakt_var_770.release_value(); }));
+__jakt_label_693:; __jakt_var_769.release_value(); }));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_771; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_770; {
 if ((open_parens == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext((JaktInternal::checked_sub<size_t>(open_parens,static_cast<size_t>(1ULL))),open_curlies,open_squares,open_angles,seen_start) } ))));
-__jakt_var_771 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_694;
+__jakt_var_770 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_694;
 
 }
-__jakt_label_694:; __jakt_var_771.release_value(); }));
+__jakt_label_694:; __jakt_var_770.release_value(); }));
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_772; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_771; {
 if (seen_start){
 ((((*this).index)--));
 ((*this).pop_state());
@@ -4476,84 +4428,84 @@ return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,(JaktInternal::checked_add<size_t>(open_curlies,static_cast<size_t>(1ULL))),open_squares,open_angles,true) } ))));
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_772 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_695;
+__jakt_var_771 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_695;
 
 }
-__jakt_label_695:; __jakt_var_772.release_value(); }));
+__jakt_label_695:; __jakt_var_771.release_value(); }));
 };/*case end*/
 case 10: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_773; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_772; {
 if ((open_curlies == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_sub<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,(JaktInternal::checked_sub<size_t>(open_curlies,static_cast<size_t>(1ULL))),open_squares,open_angles,seen_start) } ))));
-__jakt_var_773 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_696;
+__jakt_var_772 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_696;
 
 }
-__jakt_label_696:; __jakt_var_773.release_value(); }));
+__jakt_label_696:; __jakt_var_772.release_value(); }));
 };/*case end*/
 case 91: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_774; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_773; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,open_squares,open_angles,true) } ))));
-__jakt_var_774 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_697;
+__jakt_var_773 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_697;
 
 }
-__jakt_label_697:; __jakt_var_774.release_value(); }));
+__jakt_label_697:; __jakt_var_773.release_value(); }));
 };/*case end*/
 case 84: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_775; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_774; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,open_squares,open_angles,true) } ))));
-__jakt_var_775 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_698;
+__jakt_var_774 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_698;
 
 }
-__jakt_label_698:; __jakt_var_775.release_value(); }));
+__jakt_label_698:; __jakt_var_774.release_value(); }));
 };/*case end*/
 case 37: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_776; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_775; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,open_squares,open_angles,true) } ))));
-__jakt_var_776 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_699;
+__jakt_var_775 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_699;
 
 }
-__jakt_label_699:; __jakt_var_776.release_value(); }));
+__jakt_label_699:; __jakt_var_775.release_value(); }));
 };/*case end*/
 case 75: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_777; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_776; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,open_squares,open_angles,true) } ))));
 TRY((((*this).push_state( formatter::State { typename formatter::State::FunctionTypeContext(false) } ))));
-__jakt_var_777 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_700;
+__jakt_var_776 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_700;
 
 }
-__jakt_label_700:; __jakt_var_777.release_value(); }));
+__jakt_label_700:; __jakt_var_776.release_value(); }));
 };/*case end*/
 case 52: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_778; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_777; {
 if (((JaktInternal::checked_add<size_t>(open_angles,open_parens)) == static_cast<size_t>(0ULL))){
 ((((*this).index)--));
 ((*this).pop_state());
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_778 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_701;
+__jakt_var_777 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_701;
 
 }
-__jakt_label_701:; __jakt_var_778.release_value(); }));
+__jakt_label_701:; __jakt_var_777.release_value(); }));
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_779; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_778; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::TypeContext(open_parens,open_curlies,open_squares,open_angles,true) } ))));
-__jakt_var_779 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_702;
+__jakt_var_778 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_702;
 
 }
-__jakt_label_702:; __jakt_var_779.release_value(); }));
+__jakt_label_702:; __jakt_var_778.release_value(); }));
 };/*case end*/
 case 104: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_780; {
-__jakt_var_780 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_703;
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_779; {
+__jakt_var_779 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_703;
 
 }
-__jakt_label_703:; __jakt_var_780.release_value(); }));
+__jakt_label_703:; __jakt_var_779.release_value(); }));
 };/*case end*/
 case 16: {
 {
@@ -4603,7 +4555,7 @@ return (TRY((((*this).next_impl(true)))));
 }
 };/*case end*/
 case 58: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_781; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_780; {
 if (seen_final_type){
 ((*this).pop_state());
 ((((*this).index)--));
@@ -4611,32 +4563,32 @@ return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::FunctionTypeContext(true) } ))));
 TRY((((*this).push_state( formatter::State { typename formatter::State::TypeContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false) } ))));
-__jakt_var_781 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_704;
+__jakt_var_780 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_704;
 
 }
-__jakt_label_704:; __jakt_var_781.release_value(); }));
+__jakt_label_704:; __jakt_var_780.release_value(); }));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_782; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_781; {
 if (seen_final_type){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).push_state( formatter::State { typename formatter::State::ParameterList(static_cast<size_t>(0ULL)) } ))));
-__jakt_var_782 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_705;
+__jakt_var_781 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_705;
 
 }
-__jakt_label_705:; __jakt_var_782.release_value(); }));
+__jakt_label_705:; __jakt_var_781.release_value(); }));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_783; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_782; {
 if (seen_final_type){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
-__jakt_var_783 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
+__jakt_var_782 = formatter::FormattedToken(token,((*this).indent),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<u8>, ErrorOr<JaktInternal::Optional<formatter::FormattedToken>>>{
 auto&& __jakt_match_variant = ((*this).peek(static_cast<i64>(0LL)));
 switch(__jakt_match_variant.index()) {
 case 99: {
@@ -4650,22 +4602,22 @@ return JaktInternal::ExplicitValue((TRY((DynamicArray<u8>::create_with({})))));
 )),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_706;
 
 }
-__jakt_label_706:; __jakt_var_783.release_value(); }));
+__jakt_label_706:; __jakt_var_782.release_value(); }));
 };/*case end*/
 case 99: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_784; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_783; {
 if (seen_final_type){
 ((*this).pop_state());
 ((((*this).index)--));
 return (TRY((((*this).next_impl(true)))));
 }
-__jakt_var_784 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_707;
+__jakt_var_783 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_707;
 
 }
-__jakt_label_707:; __jakt_var_784.release_value(); }));
+__jakt_label_707:; __jakt_var_783.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
@@ -4678,53 +4630,53 @@ return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_R
 auto&& __jakt_match_variant = token;
 switch(__jakt_match_variant.index()) {
 case 7: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_785; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_784; {
 TRY((((*this).replace_state( formatter::State { typename formatter::State::MatchPattern((JaktInternal::checked_add<size_t>(open_parens,static_cast<size_t>(1ULL))),allow_multiple) } ))));
 TRY((((*this).push_state( formatter::State { typename formatter::State::StatementContext(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),false, formatter::ExpressionMode { typename formatter::ExpressionMode::OutsideExpression() } ,static_cast<size_t>(0ULL)) } ))));
-__jakt_var_785 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_708;
+__jakt_var_784 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_708;
 
 }
-__jakt_label_708:; __jakt_var_785.release_value(); }));
+__jakt_label_708:; __jakt_var_784.release_value(); }));
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_786; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_785; {
 if ((open_parens == static_cast<size_t>(0ULL))){
 ((*this).pop_state());
 ({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_sub<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 return (TRY((((*this).next_impl(true)))));
 }
 TRY((((*this).replace_state( formatter::State { typename formatter::State::MatchPattern((JaktInternal::checked_sub<size_t>(open_parens,static_cast<size_t>(1ULL))),allow_multiple) } ))));
-__jakt_var_786 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_709;
+__jakt_var_785 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_709;
 
 }
-__jakt_label_709:; __jakt_var_786.release_value(); }));
+__jakt_label_709:; __jakt_var_785.release_value(); }));
 };/*case end*/
 case 55: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_787; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_786; {
 if ((!(allow_multiple))){
 ((*this).pop_state());
 ({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_sub<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 return (TRY((((*this).next_impl(true)))));
 }
-__jakt_var_787 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_710;
+__jakt_var_786 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))); goto __jakt_label_710;
 
 }
-__jakt_label_710:; __jakt_var_787.release_value(); }));
+__jakt_label_710:; __jakt_var_786.release_value(); }));
 };/*case end*/
 case 3: {
 return JaktInternal::ExplicitValue(formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({})))),(TRY((DynamicArray<u8>::create_with({}))))));
 };/*case end*/
 case 40: {
-return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_788; {
+return JaktInternal::ExplicitValue(({ Optional<formatter::FormattedToken> __jakt_var_787; {
 if ((!(allow_multiple))){
 ((*this).pop_state());
 ({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_sub<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 return (TRY((((*this).next_impl(true)))));
 }
-__jakt_var_788 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_711;
+__jakt_var_787 = formatter::FormattedToken(token,((*this).indent),(TRY((DynamicArray<u8>::create_with({' '})))),(TRY((DynamicArray<u8>::create_with({' '}))))); goto __jakt_label_711;
 
 }
-__jakt_label_711:; __jakt_var_788.release_value(); }));
+__jakt_label_711:; __jakt_var_787.release_value(); }));
 };/*case end*/
 default: {
 {
@@ -4743,39 +4695,56 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-lexer::Token formatter::Stage0::peek(i64 const offset) const {
+lexer::Token formatter::Stage0::consume() {
 {
-size_t const effective_index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,lexer::Token>{
-auto __jakt_enum_value = (offset);
-if (__jakt_enum_value == static_cast<i64>(0LL)) {
-return JaktInternal::ExplicitValue(((*this).index));
+return (((((*this).tokens))[((((*this).index)++))]));
 }
-else {
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>(((JaktInternal::checked_sub<i64>((JaktInternal::checked_add<i64>((infallible_integer_cast<i64>((((*this).index)))),offset)),static_cast<i64>(1LL)))))));
 }
-}()))
-;
-if ((effective_index >= ((((*this).tokens)).size()))){
-return ( lexer::Token { typename lexer::Token::Eof((((((((*this).tokens)).last()).value())).span())) } );
+
+formatter::Stage0::Stage0(JaktInternal::DynamicArray<lexer::Token> a_tokens, size_t a_index, JaktInternal::DynamicArray<formatter::State> a_states, size_t a_indent, bool a_already_seen_enclosure_in_current_line, JaktInternal::DynamicArray<size_t> a_dedents_to_skip, bool a_debug) :tokens(move(a_tokens)), index(move(a_index)), states(move(a_states)), indent(move(a_indent)), already_seen_enclosure_in_current_line(move(a_already_seen_enclosure_in_current_line)), dedents_to_skip(move(a_dedents_to_skip)), debug(move(a_debug)){}
+
+formatter::State formatter::Stage0::state() const {
+{
+return ((((((*this).states)).last()).value()));
 }
-return (((((*this).tokens))[effective_index]));
+}
+
+ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> formatter::Stage0::formatted_peek() {
+{
+JaktInternal::DynamicArray<formatter::State> const states_cache = TRY((((((((*this).states))[(JaktInternal::Range<i64>{static_cast<i64>(0LL),static_cast<i64>(9223372036854775807LL)})])).to_array())));
+size_t const index_cache = ((*this).index);
+JaktInternal::Optional<formatter::FormattedToken> const token = TRY((((*this).next_impl(true))));
+(((*this).index) = index_cache);
+(((*this).states) = states_cache);
+return (token);
 }
 }
 
-bool formatter::Stage0::line_has_indent() const {
+ErrorOr<formatter::Stage0> formatter::Stage0::for_tokens(JaktInternal::DynamicArray<lexer::Token> const tokens,bool const debug) {
 {
-i64 offset = static_cast<i64>(0LL);
-for (;;){
-lexer::Token const token = ((*this).peek(offset));
-if (((token).index() == 9 /* LCurly */)){
-return (true);
+return (formatter::Stage0(tokens,static_cast<size_t>(0ULL),(TRY((DynamicArray<formatter::State>::create_with({ formatter::State { typename formatter::State::Toplevel(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)) } })))),static_cast<size_t>(0ULL),false,(TRY((DynamicArray<size_t>::create_with({static_cast<size_t>(0ULL)})))),debug));
 }
-if ((((token).index() == 55 /* Eol */) || ((token).index() == 56 /* Eof */))){
-break;
 }
-((offset++));
+
+ErrorOr<void> formatter::Stage0::push_state(formatter::State const state) {
+{
+TRY((((((*this).states)).push(state))));
 }
-return (false);
+return {};
+}
+
+ErrorOr<formatter::Stage0> formatter::Stage0::create(NonnullRefPtr<compiler::Compiler> compiler,JaktInternal::DynamicArray<u8> const source,bool const debug) {
+{
+JaktInternal::DynamicArray<u8> const old_file_contents = ((compiler)->current_file_contents);
+(((compiler)->current_file_contents) = source);
+ScopeGuard __jakt_var_788([&] {
+{
+(((compiler)->current_file_contents) = old_file_contents);
+}
+
+});
+JaktInternal::DynamicArray<lexer::Token> const tokens = TRY((lexer::Lexer::lex(compiler)));
+return (formatter::Stage0(tokens,static_cast<size_t>(0ULL),(TRY((DynamicArray<formatter::State>::create_with({ formatter::State { typename formatter::State::Toplevel(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)) } })))),static_cast<size_t>(0ULL),false,(TRY((DynamicArray<size_t>::create_with({static_cast<size_t>(0ULL)})))),debug));
 }
 }
 
@@ -4801,143 +4770,59 @@ return (res);
 }
 }
 
-ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> formatter::Stage0::formatted_peek() {
+ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> formatter::Stage0::next() {
 {
-JaktInternal::DynamicArray<formatter::State> const states_cache = TRY((((((((*this).states))[(JaktInternal::Range<i64>{static_cast<i64>(0LL),static_cast<i64>(9223372036854775807LL)})])).to_array())));
-size_t const index_cache = ((*this).index);
-JaktInternal::Optional<formatter::FormattedToken> const token = TRY((((*this).next_impl(true))));
-(((*this).index) = index_cache);
-(((*this).states) = states_cache);
-return (token);
+return (TRY((((*this).next_impl(false)))));
 }
 }
 
-void formatter::Stage0::pop_state() {
+ErrorOr<void> formatter::Stage0::replace_state(formatter::State const state) {
 {
 JaktInternal::Optional<formatter::State> const dummy = ((((*this).states)).pop());
+TRY((((((*this).states)).push(state))));
 }
+return {};
 }
 
-formatter::Stage0::Stage0(JaktInternal::DynamicArray<lexer::Token> a_tokens, size_t a_index, JaktInternal::DynamicArray<formatter::State> a_states, size_t a_indent, bool a_already_seen_enclosure_in_current_line, JaktInternal::DynamicArray<size_t> a_dedents_to_skip, bool a_debug) :tokens(move(a_tokens)), index(move(a_index)), states(move(a_states)), indent(move(a_indent)), already_seen_enclosure_in_current_line(move(a_already_seen_enclosure_in_current_line)), dedents_to_skip(move(a_dedents_to_skip)), debug(move(a_debug)){}
-
-lexer::Token formatter::Stage0::consume() {
+bool formatter::Stage0::line_has_indent() const {
 {
-return (((((*this).tokens))[((((*this).index)++))]));
+i64 offset = static_cast<i64>(0LL);
+for (;;){
+lexer::Token const token = ((*this).peek(offset));
+if (((token).index() == 9 /* LCurly */)){
+return (true);
 }
+if ((((token).index() == 55 /* Eol */) || ((token).index() == 56 /* Eof */))){
+break;
 }
-
-ErrorOr<DeprecatedString> formatter::BreakablePoint::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Paren */: {
-TRY(builder.append("BreakablePoint::Paren"sv));
-[[maybe_unused]] auto const& that = this->template get<BreakablePoint::Paren>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("point: {}", that.point));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("length: {}", that.length));
+((offset++));
 }
-TRY(builder.append(")"sv));
-break;}
-case 1 /* Curly */: {
-TRY(builder.append("BreakablePoint::Curly"sv));
-[[maybe_unused]] auto const& that = this->template get<BreakablePoint::Curly>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("point: {}", that.point));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("length: {}", that.length));
+return (false);
 }
-TRY(builder.append(")"sv));
-break;}
-case 2 /* Square */: {
-TRY(builder.append("BreakablePoint::Square"sv));
-[[maybe_unused]] auto const& that = this->template get<BreakablePoint::Square>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("point: {}", that.point));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("length: {}", that.length));
 }
-TRY(builder.append(")"sv));
-break;}
-case 3 /* Logical */: {
-TRY(builder.append("BreakablePoint::Logical"sv));
-[[maybe_unused]] auto const& that = this->template get<BreakablePoint::Logical>();
-TRY(builder.append("("sv));
+
+void formatter::Stage0::pop_state() {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("point: {}", that.point));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("length: {}", that.length));
-}
-TRY(builder.append(")"sv));
-break;}
+JaktInternal::Optional<formatter::State> const dummy = ((((*this).states)).pop());
 }
-return builder.to_string();
 }
-size_t formatter::BreakablePoint::length() const {
+
+lexer::Token formatter::Stage0::peek(i64 const offset) const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, size_t>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Paren>();size_t const& length = __jakt_match_value.length;
-return JaktInternal::ExplicitValue(length);
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Curly>();size_t const& length = __jakt_match_value.length;
-return JaktInternal::ExplicitValue(length);
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Square>();size_t const& length = __jakt_match_value.length;
-return JaktInternal::ExplicitValue(length);
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Logical>();size_t const& length = __jakt_match_value.length;
-return JaktInternal::ExplicitValue(length);
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+size_t const effective_index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,lexer::Token>{
+auto __jakt_enum_value = (offset);
+if (__jakt_enum_value == static_cast<i64>(0LL)) {
+return JaktInternal::ExplicitValue(((*this).index));
 }
+else {
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>(((JaktInternal::checked_sub<i64>((JaktInternal::checked_add<i64>((infallible_integer_cast<i64>((((*this).index)))),offset)),static_cast<i64>(1LL)))))));
 }
-
-size_t formatter::BreakablePoint::point() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, size_t>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Paren>();size_t const& point = __jakt_match_value.point;
-return JaktInternal::ExplicitValue(point);
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Curly>();size_t const& point = __jakt_match_value.point;
-return JaktInternal::ExplicitValue(point);
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Square>();size_t const& point = __jakt_match_value.point;
-return JaktInternal::ExplicitValue(point);
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Logical>();size_t const& point = __jakt_match_value.point;
-return JaktInternal::ExplicitValue(point);
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+}()))
+;
+if ((effective_index >= ((((*this).tokens)).size()))){
+return ( lexer::Token { typename lexer::Token::Eof((((((((*this).tokens)).last()).value())).span())) } );
+}
+return (((((*this).tokens))[effective_index]));
 }
 }
 
@@ -5187,6 +5072,138 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
+ErrorOr<DeprecatedString> formatter::ExpressionMode::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* OutsideExpression */: {
+return DeprecatedString("ExpressionMode::OutsideExpression"sv);
+break;}
+case 1 /* BeforeExpressions */: {
+return DeprecatedString("ExpressionMode::BeforeExpressions"sv);
+break;}
+case 2 /* AtExpressionStart */: {
+return DeprecatedString("ExpressionMode::AtExpressionStart"sv);
+break;}
+case 3 /* InExpression */: {
+return DeprecatedString("ExpressionMode::InExpression"sv);
+break;}
+}
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> formatter::BreakablePoint::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Paren */: {
+TRY(builder.append("BreakablePoint::Paren"sv));
+[[maybe_unused]] auto const& that = this->template get<BreakablePoint::Paren>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("point: {}", that.point));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("length: {}", that.length));
+}
+TRY(builder.append(")"sv));
+break;}
+case 1 /* Curly */: {
+TRY(builder.append("BreakablePoint::Curly"sv));
+[[maybe_unused]] auto const& that = this->template get<BreakablePoint::Curly>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("point: {}", that.point));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("length: {}", that.length));
+}
+TRY(builder.append(")"sv));
+break;}
+case 2 /* Square */: {
+TRY(builder.append("BreakablePoint::Square"sv));
+[[maybe_unused]] auto const& that = this->template get<BreakablePoint::Square>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("point: {}", that.point));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("length: {}", that.length));
+}
+TRY(builder.append(")"sv));
+break;}
+case 3 /* Logical */: {
+TRY(builder.append("BreakablePoint::Logical"sv));
+[[maybe_unused]] auto const& that = this->template get<BreakablePoint::Logical>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("point: {}", that.point));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("length: {}", that.length));
+}
+TRY(builder.append(")"sv));
+break;}
+}
+return builder.to_string();
+}
+size_t formatter::BreakablePoint::length() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, size_t>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Paren>();size_t const& length = __jakt_match_value.length;
+return JaktInternal::ExplicitValue(length);
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Curly>();size_t const& length = __jakt_match_value.length;
+return JaktInternal::ExplicitValue(length);
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Square>();size_t const& length = __jakt_match_value.length;
+return JaktInternal::ExplicitValue(length);
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Logical>();size_t const& length = __jakt_match_value.length;
+return JaktInternal::ExplicitValue(length);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
+size_t formatter::BreakablePoint::point() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, size_t>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Paren>();size_t const& point = __jakt_match_value.point;
+return JaktInternal::ExplicitValue(point);
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Curly>();size_t const& point = __jakt_match_value.point;
+return JaktInternal::ExplicitValue(point);
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Square>();size_t const& point = __jakt_match_value.point;
+return JaktInternal::ExplicitValue(point);
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<formatter::BreakablePoint::Logical>();size_t const& point = __jakt_match_value.point;
+return JaktInternal::ExplicitValue(point);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
 ErrorOr<DeprecatedString> formatter::Entity::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
 switch (this->index()) {case 0 /* Struct */: {
@@ -5247,22 +5264,5 @@ return JaktInternal::ExplicitValue( formatter::Entity { typename formatter::Enti
 }
 }
 
-ErrorOr<DeprecatedString> formatter::ExpressionMode::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* OutsideExpression */: {
-return DeprecatedString("ExpressionMode::OutsideExpression"sv);
-break;}
-case 1 /* BeforeExpressions */: {
-return DeprecatedString("ExpressionMode::BeforeExpressions"sv);
-break;}
-case 2 /* AtExpressionStart */: {
-return DeprecatedString("ExpressionMode::AtExpressionStart"sv);
-break;}
-case 3 /* InExpression */: {
-return DeprecatedString("ExpressionMode::InExpression"sv);
-break;}
-}
-return builder.to_string();
-}
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/formatter.h b/bootstrap/stage0/formatter.h
index 0ff19dc1f..faf1b3e52 100644
--- a/bootstrap/stage0/formatter.h
+++ b/bootstrap/stage0/formatter.h
@@ -52,7 +52,46 @@ ErrorOr<DeprecatedString> debug_description() const;
 size_t length() const;
 size_t point() const;
 };
-namespace Entity_Details {
+struct Stage0 {
+  public:
+JaktInternal::DynamicArray<lexer::Token> tokens;size_t index;JaktInternal::DynamicArray<formatter::State> states;size_t indent;bool already_seen_enclosure_in_current_line;JaktInternal::DynamicArray<size_t> dedents_to_skip;bool debug;ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> next_impl(bool const reconsume);
+lexer::Token consume();
+Stage0(JaktInternal::DynamicArray<lexer::Token> a_tokens, size_t a_index, JaktInternal::DynamicArray<formatter::State> a_states, size_t a_indent, bool a_already_seen_enclosure_in_current_line, JaktInternal::DynamicArray<size_t> a_dedents_to_skip, bool a_debug);
+
+formatter::State state() const;
+ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> formatted_peek();
+static ErrorOr<formatter::Stage0> for_tokens(JaktInternal::DynamicArray<lexer::Token> const tokens, bool const debug);
+ErrorOr<void> push_state(formatter::State const state);
+static ErrorOr<formatter::Stage0> create(NonnullRefPtr<compiler::Compiler> compiler, JaktInternal::DynamicArray<u8> const source, bool const debug);
+static ErrorOr<JaktInternal::DynamicArray<u8>> to_array(DeprecatedString const x);
+ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> next();
+ErrorOr<void> replace_state(formatter::State const state);
+bool line_has_indent() const;
+void pop_state();
+lexer::Token peek(i64 const offset) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};struct Formatter {
+  public:
+formatter::Stage0 token_provider;JaktInternal::DynamicArray<formatter::ReflowState> current_line;size_t current_line_length;size_t max_allowed_line_length;JaktInternal::DynamicArray<formatter::BreakablePoint> breakable_points_in_current_line;JaktInternal::DynamicArray<formatter::ReflowState> tokens_to_reflow;JaktInternal::DynamicArray<JaktInternal::Optional<lexer::Token>> replace_commas_in_enclosure;size_t enclosures_to_ignore;bool in_condition_expr;bool in_condition_expr_indented;JaktInternal::Optional<size_t> logical_break_indent;size_t empty_line_count;ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<formatter::FormattedToken>>> next();
+static bool should_ignore_state(formatter::State const state);
+ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> peek();
+static ErrorOr<formatter::Formatter> for_tokens(JaktInternal::DynamicArray<lexer::Token> const tokens, bool const debug, size_t const max_allowed_line_length);
+static ErrorOr<JaktInternal::DynamicArray<u8>> to_array(DeprecatedString const s);
+ErrorOr<void> fixup_tokens_to_reflow();
+Formatter(formatter::Stage0 a_token_provider, JaktInternal::DynamicArray<formatter::ReflowState> a_current_line, size_t a_current_line_length, size_t a_max_allowed_line_length, JaktInternal::DynamicArray<formatter::BreakablePoint> a_breakable_points_in_current_line, JaktInternal::DynamicArray<formatter::ReflowState> a_tokens_to_reflow, JaktInternal::DynamicArray<JaktInternal::Optional<lexer::Token>> a_replace_commas_in_enclosure, size_t a_enclosures_to_ignore, bool a_in_condition_expr, bool a_in_condition_expr_indented, JaktInternal::Optional<size_t> a_logical_break_indent, size_t a_empty_line_count);
+
+ErrorOr<size_t> token_length(formatter::FormattedToken const token) const;
+ErrorOr<void> fixup_closing_enclosures(JaktInternal::DynamicArray<formatter::ReflowState>& line) const;
+size_t pick_breaking_point_index() const;
+ErrorOr<DeprecatedString> debug_description() const;
+};struct FormattedToken {
+  public:
+lexer::Token token;size_t indent;JaktInternal::DynamicArray<u8> trailing_trivia;JaktInternal::DynamicArray<u8> preceding_trivia;FormattedToken(lexer::Token a_token, size_t a_indent, JaktInternal::DynamicArray<u8> a_trailing_trivia, JaktInternal::DynamicArray<u8> a_preceding_trivia);
+
+ErrorOr<DeprecatedString> token_text() const;
+ErrorOr<DeprecatedString> debug_text() const;
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace Entity_Details {
 struct Struct {
 };
 struct Enum {
@@ -236,55 +275,16 @@ using Variant<State_Details::Toplevel, State_Details::Import, State_Details::Imp
 ErrorOr<DeprecatedString> debug_description() const;
 ErrorOr<DeprecatedString> name() const;
 };
-struct Stage0 {
-  public:
-JaktInternal::DynamicArray<lexer::Token> tokens;size_t index;JaktInternal::DynamicArray<formatter::State> states;size_t indent;bool already_seen_enclosure_in_current_line;JaktInternal::DynamicArray<size_t> dedents_to_skip;bool debug;ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> next();
-ErrorOr<void> replace_state(formatter::State const state);
-formatter::State state() const;
-ErrorOr<void> push_state(formatter::State const state);
-static ErrorOr<formatter::Stage0> for_tokens(JaktInternal::DynamicArray<lexer::Token> const tokens, bool const debug);
-static ErrorOr<formatter::Stage0> create(NonnullRefPtr<compiler::Compiler> compiler, JaktInternal::DynamicArray<u8> const source, bool const debug);
-ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> next_impl(bool const reconsume);
-lexer::Token peek(i64 const offset) const;
-bool line_has_indent() const;
-static ErrorOr<JaktInternal::DynamicArray<u8>> to_array(DeprecatedString const x);
-ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> formatted_peek();
-void pop_state();
-Stage0(JaktInternal::DynamicArray<lexer::Token> a_tokens, size_t a_index, JaktInternal::DynamicArray<formatter::State> a_states, size_t a_indent, bool a_already_seen_enclosure_in_current_line, JaktInternal::DynamicArray<size_t> a_dedents_to_skip, bool a_debug);
-
-lexer::Token consume();
-ErrorOr<DeprecatedString> debug_description() const;
-};struct Formatter {
-  public:
-formatter::Stage0 token_provider;JaktInternal::DynamicArray<formatter::ReflowState> current_line;size_t current_line_length;size_t max_allowed_line_length;JaktInternal::DynamicArray<formatter::BreakablePoint> breakable_points_in_current_line;JaktInternal::DynamicArray<formatter::ReflowState> tokens_to_reflow;JaktInternal::DynamicArray<JaktInternal::Optional<lexer::Token>> replace_commas_in_enclosure;size_t enclosures_to_ignore;bool in_condition_expr;bool in_condition_expr_indented;JaktInternal::Optional<size_t> logical_break_indent;size_t empty_line_count;ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<formatter::FormattedToken>>> next();
-static bool should_ignore_state(formatter::State const state);
-Formatter(formatter::Stage0 a_token_provider, JaktInternal::DynamicArray<formatter::ReflowState> a_current_line, size_t a_current_line_length, size_t a_max_allowed_line_length, JaktInternal::DynamicArray<formatter::BreakablePoint> a_breakable_points_in_current_line, JaktInternal::DynamicArray<formatter::ReflowState> a_tokens_to_reflow, JaktInternal::DynamicArray<JaktInternal::Optional<lexer::Token>> a_replace_commas_in_enclosure, size_t a_enclosures_to_ignore, bool a_in_condition_expr, bool a_in_condition_expr_indented, JaktInternal::Optional<size_t> a_logical_break_indent, size_t a_empty_line_count);
-
-ErrorOr<size_t> token_length(formatter::FormattedToken const token) const;
-ErrorOr<JaktInternal::Optional<formatter::FormattedToken>> peek();
-static ErrorOr<formatter::Formatter> for_tokens(JaktInternal::DynamicArray<lexer::Token> const tokens, bool const debug, size_t const max_allowed_line_length);
-static ErrorOr<JaktInternal::DynamicArray<u8>> to_array(DeprecatedString const s);
-ErrorOr<void> fixup_tokens_to_reflow();
-ErrorOr<void> fixup_closing_enclosures(JaktInternal::DynamicArray<formatter::ReflowState>& line) const;
-size_t pick_breaking_point_index() const;
-ErrorOr<DeprecatedString> debug_description() const;
-};struct FormattedToken {
-  public:
-lexer::Token token;size_t indent;JaktInternal::DynamicArray<u8> trailing_trivia;JaktInternal::DynamicArray<u8> preceding_trivia;FormattedToken(lexer::Token a_token, size_t a_indent, JaktInternal::DynamicArray<u8> a_trailing_trivia, JaktInternal::DynamicArray<u8> a_preceding_trivia);
-
-ErrorOr<DeprecatedString> token_text() const;
-ErrorOr<DeprecatedString> debug_text() const;
-ErrorOr<DeprecatedString> debug_description() const;
-};struct ReflowState {
+struct ReflowState {
   public:
 formatter::FormattedToken token;formatter::State state;size_t enclosures_to_ignore;ReflowState(formatter::FormattedToken a_token, formatter::State a_state, size_t a_enclosures_to_ignore);
 
 ErrorOr<DeprecatedString> debug_description() const;
 };template <typename T>
-JaktInternal::Optional<T> collapse(JaktInternal::Optional<JaktInternal::Optional<T>> const x);
-template <typename T>
 ErrorOr<JaktInternal::DynamicArray<T>> concat(JaktInternal::DynamicArray<T> const xs, T const y);
 template <typename T>
+JaktInternal::Optional<T> collapse(JaktInternal::Optional<JaktInternal::Optional<T>> const x);
+template <typename T>
 ErrorOr<JaktInternal::DynamicArray<T>> init(JaktInternal::DynamicArray<T> const xs);
 }
 } // namespace Jakt
@@ -294,38 +294,38 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::formatter::Entity> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::Entity const& value) {
+template<>struct Jakt::Formatter<Jakt::formatter::Stage0> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::Stage0 const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::formatter::ExpressionMode> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::ExpressionMode const& value) {
+template<>struct Jakt::Formatter<Jakt::formatter::Formatter> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::Formatter const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::formatter::State> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::State const& value) {
+template<>struct Jakt::Formatter<Jakt::formatter::FormattedToken> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::FormattedToken const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::formatter::Stage0> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::Stage0 const& value) {
+template<>struct Jakt::Formatter<Jakt::formatter::Entity> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::Entity const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::formatter::Formatter> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::Formatter const& value) {
+template<>struct Jakt::Formatter<Jakt::formatter::ExpressionMode> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::ExpressionMode const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::formatter::FormattedToken> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::FormattedToken const& value) {
+template<>struct Jakt::Formatter<Jakt::formatter::State> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::formatter::State const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
diff --git a/bootstrap/stage0/ide.cpp b/bootstrap/stage0/ide.cpp
index a22707ced..2b54f60a5 100644
--- a/bootstrap/stage0/ide.cpp
+++ b/bootstrap/stage0/ide.cpp
@@ -147,100 +147,60 @@ return (ide::JaktSymbol(((record).name),JaktInternal::OptionalNone(),record_kind
 }
 }
 
-ErrorOr<JaktInternal::Optional<DeprecatedString>> find_typename_in_program(NonnullRefPtr<types::CheckedProgram> const program,utility::Span const span) {
+ErrorOr<ide::Usage> get_enum_variant_usage_from_type_id_and_name(NonnullRefPtr<types::CheckedProgram> const program,types::TypeId const type_id,DeprecatedString const name) {
 {
-JaktInternal::Optional<ide::Usage> const result = TRY((ide::find_span_in_program(program,span)));
-if (((result).has_value())){
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<DeprecatedString>, ErrorOr<JaktInternal::Optional<DeprecatedString>>>{
-auto&& __jakt_match_variant = (result.value());
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<ide::Usage::Variable>();DeprecatedString const& name = __jakt_match_value.name;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-ide::Mutability const& mutability = __jakt_match_value.mutability;
-ide::VarType const& var_type = __jakt_match_value.var_type;
-ide::VarVisibility const& visibility = __jakt_match_value.visibility;
-JaktInternal::Optional<types::TypeId> const& struct_type_id = __jakt_match_value.struct_type_id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_815; {
-DeprecatedString const result = TRY((ide::get_var_signature(program,name,type_id,mutability,var_type,visibility,struct_type_id)));
-__jakt_var_815 = static_cast<JaktInternal::Optional<DeprecatedString>>(result); goto __jakt_label_723;
-
-}
-__jakt_label_723:; __jakt_var_815.release_value(); }));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::Call>();
-types::FunctionId const& function_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_816; {
-DeprecatedString const result = TRY((ide::get_function_signature(program,function_id)));
-__jakt_var_816 = static_cast<JaktInternal::Optional<DeprecatedString>>(result); goto __jakt_label_724;
-
+{
+JaktInternal::ArrayIterator<types::CheckedEnum> _magic = ((((((program)->get_module(((type_id).module))))->enums)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedEnum> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_724:; __jakt_var_816.release_value(); }));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::Typename>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_817; {
-DeprecatedString const result = TRY((ide::get_type_signature(program,type_id)));
-__jakt_var_817 = static_cast<JaktInternal::Optional<DeprecatedString>>(result); goto __jakt_label_725;
-
+types::CheckedEnum enum_ = (_magic_value.value());
+{
+if ((!(((((enum_).type_id)).equals(type_id))))){
+continue;
 }
-__jakt_label_725:; __jakt_var_817.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::NameSet>();
-JaktInternal::DynamicArray<DeprecatedString> const& names = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_818; {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-bool first = true;
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((names).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString name = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-if ((!(first))){
-(output += Jakt::DeprecatedString(" | "sv));
-}
-else {
-(first = false);
+if ((((variant).name()) == name)){
+JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const variants = TRY((ide::enum_variant_fields(program,variant)));
+JaktInternal::Optional<types::NumberConstant> const number_constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::NumberConstant>, ErrorOr<ide::Usage>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& name = __jakt_match_value.name;
+NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->to_number_constant(program)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+}/*switch end*/
+}()
+));
+utility::Span const span = ((variant).span());
+return ( ide::Usage { typename ide::Usage::EnumVariant(span,name,type_id,variants,number_constant) } );
 }
-
-(output += name);
 }
 
 }
 }
 
-__jakt_var_818 = static_cast<JaktInternal::Optional<DeprecatedString>>(output); goto __jakt_label_726;
-
+utility::panic(Jakt::DeprecatedString("unreachable: should have found variant"sv));
 }
-__jakt_label_726:; __jakt_var_818.release_value(); }));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<ide::Usage::EnumVariant>();DeprecatedString const& name = __jakt_match_value.name;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const& variants = __jakt_match_value.variants;
-JaktInternal::Optional<types::NumberConstant> const& number_constant = __jakt_match_value.number_constant;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_819; {
-DeprecatedString const result = TRY((ide::get_enum_variant_signature(program,name,type_id,variants,number_constant)));
-__jakt_var_819 = static_cast<JaktInternal::Optional<DeprecatedString>>(result); goto __jakt_label_727;
 
 }
-__jakt_label_727:; __jakt_var_819.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-else {
-return (JaktInternal::OptionalNone());
 }
 
+utility::panic(Jakt::DeprecatedString("unreachable: should have found variant"sv));
 }
 }
 
@@ -324,60 +284,53 @@ return (output);
 }
 }
 
-ErrorOr<ide::Usage> get_enum_variant_usage_from_type_id_and_name(NonnullRefPtr<types::CheckedProgram> const program,types::TypeId const type_id,DeprecatedString const name) {
-{
-{
-JaktInternal::ArrayIterator<types::CheckedEnum> _magic = ((((((program)->get_module(((type_id).module))))->enums)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnum> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedEnum enum_ = (_magic_value.value());
+ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>> enum_variant_fields(NonnullRefPtr<types::CheckedProgram> const program,types::CheckedEnumVariant const checked_enum_variant) {
 {
-if ((!(((((enum_).type_id)).equals(type_id))))){
-continue;
-}
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>, ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>>>{
+auto&& __jakt_match_variant = checked_enum_variant;
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>> __jakt_var_815; {
+JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> output = (TRY((DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
+types::VarId field = (_magic_value.value());
 {
-if ((((variant).name()) == name)){
-JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const variants = TRY((ide::enum_variant_fields(program,variant)));
-JaktInternal::Optional<types::NumberConstant> const number_constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::NumberConstant>, ErrorOr<ide::Usage>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& name = __jakt_match_value.name;
-NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->to_number_constant(program)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-}/*switch end*/
-}()
-));
-utility::Span const span = ((variant).span());
-return ( ide::Usage { typename ide::Usage::EnumVariant(span,name,type_id,variants,number_constant) } );
-}
+NonnullRefPtr<types::CheckedVariable> const variable = ((program)->get_variable(field));
+JaktInternal::Optional<DeprecatedString> const var_name = static_cast<JaktInternal::Optional<DeprecatedString>>(((variable)->name));
+JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId> const o = (Tuple{var_name, ((variable)->type_id)});
+TRY((((output).push(o))));
 }
 
 }
 }
 
-utility::panic(Jakt::DeprecatedString("unreachable: should have found variant"sv));
-}
+__jakt_var_815 = output; goto __jakt_label_723;
 
 }
-}
+__jakt_label_723:; __jakt_var_815.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>> __jakt_var_816; {
+JaktInternal::Optional<DeprecatedString> const string_none = JaktInternal::OptionalNone();
+__jakt_var_816 = (TRY((DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>::create_with({(Tuple{string_none, type_id})})))); goto __jakt_label_724;
 
-utility::panic(Jakt::DeprecatedString("unreachable: should have found variant"sv));
+}
+__jakt_label_724:; __jakt_var_816.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue((TRY((DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>::create_with({})))));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
@@ -438,19 +391,19 @@ auto&& __jakt_match_variant = variant;
 switch(__jakt_match_variant.index()) {
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::NumberConstant>> __jakt_var_820; {
-__jakt_var_820 = ((expr)->to_number_constant(program)); goto __jakt_label_728;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::NumberConstant>> __jakt_var_817; {
+__jakt_var_817 = ((expr)->to_number_constant(program)); goto __jakt_label_725;
 
 }
-__jakt_label_728:; __jakt_var_820.release_value(); }));
+__jakt_label_725:; __jakt_var_817.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::NumberConstant>> __jakt_var_821; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::NumberConstant>> __jakt_var_818; {
 JaktInternal::Optional<types::NumberConstant> const none = JaktInternal::OptionalNone();
-__jakt_var_821 = none; goto __jakt_label_729;
+__jakt_var_818 = none; goto __jakt_label_726;
 
 }
-__jakt_label_729:; __jakt_var_821.release_value(); }));
+__jakt_label_726:; __jakt_var_818.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
@@ -571,7 +524,7 @@ return JaktInternal::ExplicitValue(((((program)->get_trait(trait_id)))->name));
 case 29: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
 types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_822; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_819; {
 JaktInternal::DynamicArray<DeprecatedString> param_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
 JaktInternal::ArrayIterator<types::TypeId> _magic = ((params).iterator());
@@ -589,10 +542,10 @@ TRY((((param_names).push(TRY((((program)->type_name(x,false))))))));
 }
 
 DeprecatedString const return_type = TRY((((program)->type_name(return_type_id,false))));
-__jakt_var_822 = TRY((__jakt_format(Jakt::DeprecatedString("fn({}) -> {}"sv),utility::join(param_names,Jakt::DeprecatedString(", "sv)),return_type))); goto __jakt_label_730;
+__jakt_var_819 = TRY((__jakt_format(Jakt::DeprecatedString("fn({}) -> {}"sv),utility::join(param_names,Jakt::DeprecatedString(", "sv)),return_type))); goto __jakt_label_727;
 
 }
-__jakt_label_730:; __jakt_var_822.release_value(); }));
+__jakt_label_727:; __jakt_var_819.release_value(); }));
 };/*case end*/
 case 25: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
@@ -602,9 +555,9 @@ return JaktInternal::ExplicitValue((Jakt::DeprecatedString("raw "sv) + TRY((ide:
 case 24: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
 types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_823; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_820; {
 types::CheckedEnum const enum_ = ((program)->get_enum(id));
-__jakt_var_823 = ((JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
+__jakt_var_820 = ((JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<DeprecatedString>>{
 auto __jakt_enum_value = (((enum_).is_boxed));
 if (__jakt_enum_value == true) {
 return JaktInternal::ExplicitValue(Jakt::DeprecatedString("boxed "sv));
@@ -613,17 +566,17 @@ else {
 return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }
 }()))
- + Jakt::DeprecatedString("enum "sv)) + ((enum_).name)); goto __jakt_label_731;
+ + Jakt::DeprecatedString("enum "sv)) + ((enum_).name)); goto __jakt_label_728;
 
 }
-__jakt_label_731:; __jakt_var_823.release_value(); }));
+__jakt_label_728:; __jakt_var_820.release_value(); }));
 };/*case end*/
 case 23: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
 types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_824; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_821; {
 types::CheckedStruct const struct_ = ((program)->get_struct(id));
-__jakt_var_824 = (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
+__jakt_var_821 = (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
 auto&& __jakt_match_variant = ((struct_).record_type);
 switch(__jakt_match_variant.index()) {
 case 1: {
@@ -639,15 +592,15 @@ utility::panic(Jakt::DeprecatedString("unreachable: should've been struct"sv));
 };/*case end*/
 }/*switch end*/
 }()
-)) + ((struct_).name)); goto __jakt_label_732;
+)) + ((struct_).name)); goto __jakt_label_729;
 
 }
-__jakt_label_732:; __jakt_var_824.release_value(); }));
+__jakt_label_729:; __jakt_var_821.release_value(); }));
 };/*case end*/
 case 22: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericResolvedType>();types::StructId const& id = __jakt_match_value.id;
 JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_825; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_822; {
 types::CheckedStruct const record = ((program)->get_struct(id));
 DeprecatedString output = ((record).name);
 (output += Jakt::DeprecatedString("<"sv));
@@ -670,15 +623,15 @@ size_t i = (_magic_value.value());
 }
 
 }
-__jakt_var_825 = (output + Jakt::DeprecatedString(">"sv)); goto __jakt_label_733;
+__jakt_var_822 = (output + Jakt::DeprecatedString(">"sv)); goto __jakt_label_730;
 
 }
-__jakt_label_733:; __jakt_var_825.release_value(); }));
+__jakt_label_730:; __jakt_var_822.release_value(); }));
 };/*case end*/
 case 20: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
 JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_826; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_823; {
 types::CheckedEnum const enum_ = ((program)->get_enum(id));
 DeprecatedString output = Jakt::DeprecatedString(""sv);
 if (((enum_).is_boxed)){
@@ -706,15 +659,15 @@ size_t i = (_magic_value.value());
 }
 
 }
-__jakt_var_826 = (output + Jakt::DeprecatedString(">"sv)); goto __jakt_label_734;
+__jakt_var_823 = (output + Jakt::DeprecatedString(">"sv)); goto __jakt_label_731;
 
 }
-__jakt_label_734:; __jakt_var_826.release_value(); }));
+__jakt_label_731:; __jakt_var_823.release_value(); }));
 };/*case end*/
 case 21: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
 JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_827; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_824; {
 NonnullRefPtr<types::CheckedTrait> const trait_ = ((program)->get_trait(id));
 DeprecatedString output = Jakt::DeprecatedString(""sv);
 (output += Jakt::DeprecatedString("trait "sv));
@@ -739,15 +692,15 @@ size_t i = (_magic_value.value());
 }
 
 }
-__jakt_var_827 = (output + Jakt::DeprecatedString(">"sv)); goto __jakt_label_735;
+__jakt_var_824 = (output + Jakt::DeprecatedString(">"sv)); goto __jakt_label_732;
 
 }
-__jakt_label_735:; __jakt_var_827.release_value(); }));
+__jakt_label_732:; __jakt_var_824.release_value(); }));
 };/*case end*/
 case 19: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
 JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_828; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_825; {
 if (((id).equals(array_struct_id))){
 if (((args).is_empty())){
 return (Jakt::DeprecatedString("[]"sv));
@@ -854,10 +807,10 @@ size_t i = (_magic_value.value());
 }
 
 }
-__jakt_var_828 = (output + Jakt::DeprecatedString(">"sv)); goto __jakt_label_736;
+__jakt_var_825 = (output + Jakt::DeprecatedString(">"sv)); goto __jakt_label_733;
 
 }
-__jakt_label_736:; __jakt_var_828.release_value(); }));
+__jakt_label_733:; __jakt_var_825.release_value(); }));
 };/*case end*/
 case 27: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
@@ -993,62 +946,6 @@ return (JaktInternal::OptionalNone());
 }
 }
 
-ErrorOr<DeprecatedString> get_constructor_signature(NonnullRefPtr<types::CheckedProgram> const program,types::FunctionId const function_id) {
-{
-NonnullRefPtr<types::CheckedFunction> const checked_function = ((program)->get_function(function_id));
-types::TypeId const type_id = ((checked_function)->return_type_id);
-NonnullRefPtr<types::Module> const mod = ((((program)->modules))[((((type_id).module)).id)]);
-{
-JaktInternal::ArrayIterator<types::CheckedStruct> _magic = ((((mod)->structures)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedStruct> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedStruct struct_ = (_magic_value.value());
-{
-if (((((struct_).type_id)).equals(type_id))){
-DeprecatedString output = TRY((ide::get_type_signature(program,type_id)));
-(output += Jakt::DeprecatedString("("sv));
-bool first = true;
-{
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedField field = (_magic_value.value());
-{
-if (first){
-(first = false);
-}
-else {
-(output += Jakt::DeprecatedString(", "sv));
-}
-
-NonnullRefPtr<types::CheckedVariable> const variable = ((program)->get_variable(((field).variable_id)));
-if (((variable)->is_mutable)){
-(output += Jakt::DeprecatedString("mut "sv));
-}
-(output += TRY((__jakt_format(Jakt::DeprecatedString("{}: {}"sv),((variable)->name),TRY((((program)->type_name(((variable)->type_id),false))))))));
-}
-
-}
-}
-
-(output += Jakt::DeprecatedString(")"sv));
-return (output);
-}
-}
-
-}
-}
-
-return (Jakt::DeprecatedString(""sv));
-}
-}
-
 ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> find_dot_completions(NonnullRefPtr<types::CheckedProgram> const program,utility::Span const span) {
 {
 JaktInternal::Optional<ide::Usage> const result = TRY((ide::find_span_in_program(program,span)));
@@ -1058,21 +955,21 @@ auto&& __jakt_match_variant = (result.value());
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<ide::Usage::Variable>();types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<DeprecatedString>> __jakt_var_829; {
-__jakt_var_829 = TRY((ide::completions_for_type_id(program,type_id))); goto __jakt_label_737;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<DeprecatedString>> __jakt_var_826; {
+__jakt_var_826 = TRY((ide::completions_for_type_id(program,type_id))); goto __jakt_label_734;
 
 }
-__jakt_label_737:; __jakt_var_829.release_value(); }));
+__jakt_label_734:; __jakt_var_826.release_value(); }));
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::Call>();
 types::FunctionId const& function_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<DeprecatedString>> __jakt_var_830; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<DeprecatedString>> __jakt_var_827; {
 types::TypeId const result_type_id = ((((program)->get_function(function_id)))->return_type_id);
-__jakt_var_830 = TRY((ide::completions_for_type_id(program,result_type_id))); goto __jakt_label_738;
+__jakt_var_827 = TRY((ide::completions_for_type_id(program,result_type_id))); goto __jakt_label_735;
 
 }
-__jakt_label_738:; __jakt_var_830.release_value(); }));
+__jakt_label_735:; __jakt_var_827.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue((TRY((DynamicArray<DeprecatedString>::create_with({})))));
@@ -1133,7 +1030,7 @@ return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktIn
 auto&& __jakt_match_variant = var_type;
 switch(__jakt_match_variant.index()) {
 case 0: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_831; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_828; {
 DeprecatedString const mut_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<DeprecatedString>>{
 auto&& __jakt_match_variant = mutability;
 switch(__jakt_match_variant.index()) {
@@ -1150,10 +1047,10 @@ return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
 }()
 ));
 DeprecatedString const type_name = TRY((ide::get_type_signature(program,var_type_id)));
-__jakt_var_831 = TRY((__jakt_format(Jakt::DeprecatedString("{} {}: {}"sv),mut_string,name,type_name))); goto __jakt_label_739;
+__jakt_var_828 = TRY((__jakt_format(Jakt::DeprecatedString("{} {}: {}"sv),mut_string,name,type_name))); goto __jakt_label_736;
 
 }
-__jakt_label_739:; __jakt_var_831.release_value(); }));
+__jakt_label_736:; __jakt_var_828.release_value(); }));
 };/*case end*/
 case 1: {
 {
@@ -1192,53 +1089,59 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>> enum_variant_fields(NonnullRefPtr<types::CheckedProgram> const program,types::CheckedEnumVariant const checked_enum_variant) {
+ErrorOr<DeprecatedString> get_constructor_signature(NonnullRefPtr<types::CheckedProgram> const program,types::FunctionId const function_id) {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>, ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>>>{
-auto&& __jakt_match_variant = checked_enum_variant;
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>> __jakt_var_832; {
-JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> output = (TRY((DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>::create_with({}))));
+NonnullRefPtr<types::CheckedFunction> const checked_function = ((program)->get_function(function_id));
+types::TypeId const type_id = ((checked_function)->return_type_id);
+NonnullRefPtr<types::Module> const mod = ((((program)->modules))[((((type_id).module)).id)]);
 {
-JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
+JaktInternal::ArrayIterator<types::CheckedStruct> _magic = ((((mod)->structures)).iterator());
 for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedStruct> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::VarId field = (_magic_value.value());
+types::CheckedStruct struct_ = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedVariable> const variable = ((program)->get_variable(field));
-JaktInternal::Optional<DeprecatedString> const var_name = static_cast<JaktInternal::Optional<DeprecatedString>>(((variable)->name));
-JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId> const o = (Tuple{var_name, ((variable)->type_id)});
-TRY((((output).push(o))));
+if (((((struct_).type_id)).equals(type_id))){
+DeprecatedString output = TRY((ide::get_type_signature(program,type_id)));
+(output += Jakt::DeprecatedString("("sv));
+bool first = true;
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedField field = (_magic_value.value());
+{
+if (first){
+(first = false);
+}
+else {
+(output += Jakt::DeprecatedString(", "sv));
 }
 
+NonnullRefPtr<types::CheckedVariable> const variable = ((program)->get_variable(((field).variable_id)));
+if (((variable)->is_mutable)){
+(output += Jakt::DeprecatedString("mut "sv));
 }
+(output += TRY((__jakt_format(Jakt::DeprecatedString("{}: {}"sv),((variable)->name),TRY((((program)->type_name(((variable)->type_id),false))))))));
 }
 
-__jakt_var_832 = output; goto __jakt_label_740;
+}
+}
 
+(output += Jakt::DeprecatedString(")"sv));
+return (output);
+}
 }
-__jakt_label_740:; __jakt_var_832.release_value(); }));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>> __jakt_var_833; {
-JaktInternal::Optional<DeprecatedString> const string_none = JaktInternal::OptionalNone();
-__jakt_var_833 = (TRY((DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>::create_with({(Tuple{string_none, type_id})})))); goto __jakt_label_741;
 
 }
-__jakt_label_741:; __jakt_var_833.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue((TRY((DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>>::create_with({})))));
-};/*case end*/
-}/*switch end*/
-}()
-)));
+}
+
+return (Jakt::DeprecatedString(""sv));
 }
 }
 
@@ -1252,29 +1155,29 @@ switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<ide::Usage::Variable>();utility::Span const& span = __jakt_match_value.span;
 types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<utility::Span> __jakt_var_834; {
-__jakt_var_834 = TRY((ide::find_type_definition_for_type_id(program,type_id,span))); goto __jakt_label_742;
+return JaktInternal::ExplicitValue(({ Optional<utility::Span> __jakt_var_829; {
+__jakt_var_829 = TRY((ide::find_type_definition_for_type_id(program,type_id,span))); goto __jakt_label_737;
 
 }
-__jakt_label_742:; __jakt_var_834.release_value(); }));
+__jakt_label_737:; __jakt_var_829.release_value(); }));
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::Call>();
 types::FunctionId const& function_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<utility::Span> __jakt_var_835; {
-__jakt_var_835 = ((((program)->get_function(function_id)))->name_span); goto __jakt_label_743;
+return JaktInternal::ExplicitValue(({ Optional<utility::Span> __jakt_var_830; {
+__jakt_var_830 = ((((program)->get_function(function_id)))->name_span); goto __jakt_label_738;
 
 }
-__jakt_label_743:; __jakt_var_835.release_value(); }));
+__jakt_label_738:; __jakt_var_830.release_value(); }));
 };/*case end*/
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::Typename>();
 types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<utility::Span> __jakt_var_836; {
-__jakt_var_836 = TRY((ide::find_type_definition_for_type_id(program,type_id,span))); goto __jakt_label_744;
+return JaktInternal::ExplicitValue(({ Optional<utility::Span> __jakt_var_831; {
+__jakt_var_831 = TRY((ide::find_type_definition_for_type_id(program,type_id,span))); goto __jakt_label_739;
 
 }
-__jakt_label_744:; __jakt_var_836.release_value(); }));
+__jakt_label_739:; __jakt_var_831.release_value(); }));
 };/*case end*/
 case 3: {
 return JaktInternal::ExplicitValue(span);
@@ -1304,20 +1207,20 @@ case 7: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& lhs = __jakt_match_value.lhs;
 parser::BinaryOperator const& op = __jakt_match_value.op;
 NonnullRefPtr<typename types::CheckedExpression> const& rhs = __jakt_match_value.rhs;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_837; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_832; {
 JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,lhs,span)));
 if (((found).has_value())){
 return (found);
 }
-__jakt_var_837 = TRY((ide::find_span_in_expression(program,rhs,span))); goto __jakt_label_745;
+__jakt_var_832 = TRY((ide::find_span_in_expression(program,rhs,span))); goto __jakt_label_740;
 
 }
-__jakt_label_745:; __jakt_var_837.release_value(); }));
+__jakt_label_740:; __jakt_var_832.release_value(); }));
 };/*case end*/
 case 10: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
 JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& repeat = __jakt_match_value.repeat;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_838; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_833; {
 {
 JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
 for (;;){
@@ -1339,10 +1242,10 @@ return (found);
 if (((repeat).has_value())){
 return (TRY((ide::find_span_in_expression(program,(repeat.value()),span))));
 }
-__jakt_var_838 = none; goto __jakt_label_746;
+__jakt_var_833 = none; goto __jakt_label_741;
 
 }
-__jakt_label_746:; __jakt_var_838.release_value(); }));
+__jakt_label_741:; __jakt_var_833.release_value(); }));
 };/*case end*/
 case 28: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
@@ -1351,7 +1254,7 @@ return JaktInternal::ExplicitValue(TRY((ide::find_span_in_block(program,block,sp
 case 21: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
 utility::Span const& call_span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_839; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_834; {
 {
 JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
 for (;;){
@@ -1377,14 +1280,14 @@ return (found);
 if ((((((call).function_id)).has_value()) && ((call_span).contains(span)))){
 return (static_cast<JaktInternal::Optional<ide::Usage>>( ide::Usage { typename ide::Usage::Call((((call).function_id).value())) } ));
 }
-__jakt_var_839 = none; goto __jakt_label_747;
+__jakt_var_834 = none; goto __jakt_label_742;
 
 }
-__jakt_label_747:; __jakt_var_839.release_value(); }));
+__jakt_label_742:; __jakt_var_834.release_value(); }));
 };/*case end*/
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_840; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_835; {
 {
 JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
 for (;;){
@@ -1411,15 +1314,15 @@ return (found);
 }
 }
 
-__jakt_var_840 = none; goto __jakt_label_748;
+__jakt_var_835 = none; goto __jakt_label_743;
 
 }
-__jakt_label_748:; __jakt_var_840.release_value(); }));
+__jakt_label_743:; __jakt_var_835.release_value(); }));
 };/*case end*/
 case 13: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
 NonnullRefPtr<typename types::CheckedExpression> const& index = __jakt_match_value.index;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_841; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_836; {
 JaktInternal::Optional<ide::Usage> found = TRY((ide::find_span_in_expression(program,expr,span)));
 if (((found).has_value())){
 return (found);
@@ -1428,17 +1331,17 @@ return (found);
 if (((found).has_value())){
 return (found);
 }
-__jakt_var_841 = none; goto __jakt_label_749;
+__jakt_var_836 = none; goto __jakt_label_744;
 
 }
-__jakt_label_749:; __jakt_var_841.release_value(); }));
+__jakt_label_744:; __jakt_var_836.release_value(); }));
 };/*case end*/
 case 16: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
 DeprecatedString const& index = __jakt_match_value.index;
 utility::Span const& index_span = __jakt_match_value.span;
 types::TypeId const& known_type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_842; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_837; {
 JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,expr,span)));
 if (((found).has_value())){
 return (found);
@@ -1486,30 +1389,30 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 
 }
 }
-__jakt_var_842 = none; goto __jakt_label_750;
+__jakt_var_837 = none; goto __jakt_label_745;
 
 }
-__jakt_label_750:; __jakt_var_842.release_value(); }));
+__jakt_label_745:; __jakt_var_837.release_value(); }));
 };/*case end*/
 case 14: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
 NonnullRefPtr<typename types::CheckedExpression> const& index = __jakt_match_value.index;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_843; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_838; {
 JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,expr,span)));
 if (((found).has_value())){
 return (found);
 }
-__jakt_var_843 = TRY((ide::find_span_in_expression(program,index,span))); goto __jakt_label_751;
+__jakt_var_838 = TRY((ide::find_span_in_expression(program,index,span))); goto __jakt_label_746;
 
 }
-__jakt_label_751:; __jakt_var_843.release_value(); }));
+__jakt_label_746:; __jakt_var_838.release_value(); }));
 };/*case end*/
 case 19: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Match>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
 JaktInternal::DynamicArray<types::CheckedMatchCase> const& match_cases = __jakt_match_value.match_cases;
 utility::Span const& match_span = __jakt_match_value.span;
 types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_844; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_839; {
 {
 JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
 for (;;){
@@ -1530,11 +1433,11 @@ size_t const& index = __jakt_match_value.index;
 types::ScopeId const& scope_id = __jakt_match_value.scope_id;
 types::CheckedMatchBody const& body = __jakt_match_value.body;
 utility::Span const& marker_span = __jakt_match_value.marker_span;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_845; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_840; {
 if (((marker_span).contains(span))){
 return (static_cast<JaktInternal::Optional<ide::Usage>>(TRY((ide::get_enum_variant_usage_from_type_id_and_name(program,subject_type_id,name)))));
 }
-__jakt_var_845 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>, ErrorOr<JaktInternal::Optional<ide::Usage>>>{
+__jakt_var_840 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>, ErrorOr<JaktInternal::Optional<ide::Usage>>>{
 auto&& __jakt_match_variant = body;
 switch(__jakt_match_variant.index()) {
 case 1: {
@@ -1549,20 +1452,20 @@ return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,exp
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)); goto __jakt_label_753;
+)); goto __jakt_label_748;
 
 }
-__jakt_label_753:; __jakt_var_845.release_value(); }));
+__jakt_label_748:; __jakt_var_840.release_value(); }));
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expression;
 types::CheckedMatchBody const& body = __jakt_match_value.body;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_846; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_841; {
 JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,expr,span)));
 if (((found).has_value())){
 return (found);
 }
-__jakt_var_846 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>, ErrorOr<JaktInternal::Optional<ide::Usage>>>{
+__jakt_var_841 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>, ErrorOr<JaktInternal::Optional<ide::Usage>>>{
 auto&& __jakt_match_variant = body;
 switch(__jakt_match_variant.index()) {
 case 1: {
@@ -1577,10 +1480,10 @@ return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,exp
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)); goto __jakt_label_754;
+)); goto __jakt_label_749;
 
 }
-__jakt_label_754:; __jakt_var_846.release_value(); }));
+__jakt_label_749:; __jakt_var_841.release_value(); }));
 };/*case end*/
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
@@ -1588,14 +1491,14 @@ utility::Span const& marker_span = __jakt_match_value.marker_span;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
 auto __jakt_enum_value = (((marker_span).contains(span)));
 if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_847; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_842; {
 JaktInternal::Set<DeprecatedString> const all_cases = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Set<DeprecatedString>, ErrorOr<JaktInternal::Optional<ide::Usage>>>{
 auto&& __jakt_match_variant = *((program)->get_type(type_id));
 switch(__jakt_match_variant.index()) {
 case 24: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
 types::EnumId const& enum_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Set<DeprecatedString>> __jakt_var_848; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Set<DeprecatedString>> __jakt_var_843; {
 JaktInternal::Set<DeprecatedString> names = (TRY((Set<DeprecatedString>::create_with_values({}))));
 types::CheckedEnum const enum_ = ((program)->get_enum(enum_id));
 {
@@ -1613,14 +1516,14 @@ TRY((((names).add(((variant).name())))));
 }
 }
 
-__jakt_var_848 = names; goto __jakt_label_756;
+__jakt_var_843 = names; goto __jakt_label_751;
 
 }
-__jakt_label_756:; __jakt_var_848.release_value(); }));
+__jakt_label_751:; __jakt_var_843.release_value(); }));
 };/*case end*/
 case 20: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Set<DeprecatedString>> __jakt_var_849; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Set<DeprecatedString>> __jakt_var_844; {
 JaktInternal::Set<DeprecatedString> names = (TRY((Set<DeprecatedString>::create_with_values({}))));
 types::CheckedEnum const enum_ = ((program)->get_enum(enum_id));
 {
@@ -1638,17 +1541,17 @@ TRY((((names).add(((variant).name())))));
 }
 }
 
-__jakt_var_849 = names; goto __jakt_label_757;
+__jakt_var_844 = names; goto __jakt_label_752;
 
 }
-__jakt_label_757:; __jakt_var_849.release_value(); }));
+__jakt_label_752:; __jakt_var_844.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Set<DeprecatedString>> __jakt_var_850; {
-__jakt_var_850 = (TRY((Set<DeprecatedString>::create_with_values({TRY((__jakt_format(Jakt::DeprecatedString("else ({})"sv),TRY((((program)->type_name(type_id,false)))))))})))); goto __jakt_label_758;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Set<DeprecatedString>> __jakt_var_845; {
+__jakt_var_845 = (TRY((Set<DeprecatedString>::create_with_values({TRY((__jakt_format(Jakt::DeprecatedString("else ({})"sv),TRY((((program)->type_name(type_id,false)))))))})))); goto __jakt_label_753;
 
 }
-__jakt_label_758:; __jakt_var_850.release_value(); }));
+__jakt_label_753:; __jakt_var_845.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
@@ -1672,10 +1575,10 @@ DeprecatedString const name = ((other_case).get<types::CheckedMatchCase::EnumVar
 }
 }
 
-__jakt_var_847 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
+__jakt_var_842 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
 auto __jakt_enum_value = (((remaining_cases).is_empty()));
 if (__jakt_enum_value == false) {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_851; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_846; {
 JaktInternal::DynamicArray<DeprecatedString> cases_array = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 TRY((((cases_array).ensure_capacity(((remaining_cases).size())))));
 {
@@ -1693,19 +1596,19 @@ TRY((((cases_array).push(name))));
 }
 }
 
-__jakt_var_851 = static_cast<JaktInternal::Optional<ide::Usage>>( ide::Usage { typename ide::Usage::NameSet(cases_array) } ); goto __jakt_label_759;
+__jakt_var_846 = static_cast<JaktInternal::Optional<ide::Usage>>( ide::Usage { typename ide::Usage::NameSet(cases_array) } ); goto __jakt_label_754;
 
 }
-__jakt_label_759:; __jakt_var_851.release_value(); }));
+__jakt_label_754:; __jakt_var_846.release_value(); }));
 }
 else {
 return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
 }
 }()))
-; goto __jakt_label_755;
+; goto __jakt_label_750;
 
 }
-__jakt_label_755:; __jakt_var_847.release_value(); }));
+__jakt_label_750:; __jakt_var_842.release_value(); }));
 }
 else {
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>, ErrorOr<JaktInternal::Optional<ide::Usage>>>{
@@ -1739,10 +1642,10 @@ return (found);
 }
 }
 
-__jakt_var_844 = TRY((ide::find_span_in_expression(program,expr,span))); goto __jakt_label_752;
+__jakt_var_839 = TRY((ide::find_span_in_expression(program,expr,span))); goto __jakt_label_747;
 
 }
-__jakt_label_752:; __jakt_var_844.release_value(); }));
+__jakt_label_747:; __jakt_var_839.release_value(); }));
 };/*case end*/
 case 27: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
@@ -1815,7 +1718,7 @@ case 23: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NamespacedVar>();JaktInternal::DynamicArray<types::CheckedNamespace> const& namespaces = __jakt_match_value.namespaces;
 NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
 utility::Span const& var_span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_852; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_847; {
 if ((((var_span).contains(span)) && (!(((namespaces).is_empty()))))){
 types::CheckedNamespace const last_ns = (((namespaces).last()).value());
 if (((((TRY((((program)->get_scope(((last_ns).scope))))))->namespace_name)).has_value())){
@@ -1826,34 +1729,34 @@ return (static_cast<JaktInternal::Optional<ide::Usage>>(TRY((ide::get_enum_varia
 }
 }
 }
-__jakt_var_852 = none; goto __jakt_label_760;
+__jakt_var_847 = none; goto __jakt_label_755;
 
 }
-__jakt_label_760:; __jakt_var_852.release_value(); }));
+__jakt_label_755:; __jakt_var_847.release_value(); }));
 };/*case end*/
 case 32: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::TryBlock>();NonnullRefPtr<typename types::CheckedStatement> const& stmt = __jakt_match_value.stmt;
 DeprecatedString const& error_name = __jakt_match_value.error_name;
 types::CheckedBlock const& catch_block = __jakt_match_value.catch_block;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_853; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_848; {
 JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_statement(program,stmt,span)));
 if (((found).has_value())){
 return (found);
 }
-__jakt_var_853 = TRY((ide::find_span_in_block(program,catch_block,span))); goto __jakt_label_761;
+__jakt_var_848 = TRY((ide::find_span_in_block(program,catch_block,span))); goto __jakt_label_756;
 
 }
-__jakt_label_761:; __jakt_var_853.release_value(); }));
+__jakt_label_756:; __jakt_var_848.release_value(); }));
 };/*case end*/
 case 31: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Try>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
 JaktInternal::Optional<types::CheckedBlock> const& catch_block = __jakt_match_value.catch_block;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_854; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_849; {
 JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,expr,span)));
 if (((found).has_value())){
 return (found);
 }
-__jakt_var_854 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
+__jakt_var_849 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
 auto __jakt_enum_value = (((catch_block).has_value()));
 if (__jakt_enum_value == true) {
 return JaktInternal::ExplicitValue(TRY((ide::find_span_in_block(program,(catch_block.value()),span))));
@@ -1862,15 +1765,15 @@ else {
 return JaktInternal::ExplicitValue(none);
 }
 }()))
-; goto __jakt_label_762;
+; goto __jakt_label_757;
 
 }
-__jakt_label_762:; __jakt_var_854.release_value(); }));
+__jakt_label_757:; __jakt_var_849.release_value(); }));
 };/*case end*/
 case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& from = __jakt_match_value.from;
 JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& to = __jakt_match_value.to;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_855; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_850; {
 if (((from).has_value())){
 JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,(from.value()),span)));
 if (((found).has_value())){
@@ -1880,10 +1783,10 @@ return (found);
 if (((to).has_value())){
 return (TRY((ide::find_span_in_expression(program,(to.value()),span))));
 }
-__jakt_var_855 = none; goto __jakt_label_763;
+__jakt_var_850 = none; goto __jakt_label_758;
 
 }
-__jakt_label_763:; __jakt_var_855.release_value(); }));
+__jakt_label_758:; __jakt_var_850.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(none);
@@ -1894,30 +1797,6 @@ return JaktInternal::ExplicitValue(none);
 }
 }
 
-ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_block(NonnullRefPtr<types::CheckedProgram> const program,types::CheckedBlock const block,utility::Span const span) {
-{
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
-{
-JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_statement(program,statement,span)));
-if (((found).has_value())){
-return (found);
-}
-}
-
-}
-}
-
-return (JaktInternal::OptionalNone());
-}
-}
-
 ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_program(NonnullRefPtr<types::CheckedProgram> const program,utility::Span const span) {
 {
 JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> iterator = ((((program)->modules)).iterator());
@@ -2116,6 +1995,103 @@ return (TRY((ide::find_span_in_block(program,((checked_function)->block),span)))
 }
 }
 
+ErrorOr<JaktInternal::Optional<DeprecatedString>> find_typename_in_program(NonnullRefPtr<types::CheckedProgram> const program,utility::Span const span) {
+{
+JaktInternal::Optional<ide::Usage> const result = TRY((ide::find_span_in_program(program,span)));
+if (((result).has_value())){
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<DeprecatedString>, ErrorOr<JaktInternal::Optional<DeprecatedString>>>{
+auto&& __jakt_match_variant = (result.value());
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<ide::Usage::Variable>();DeprecatedString const& name = __jakt_match_value.name;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+ide::Mutability const& mutability = __jakt_match_value.mutability;
+ide::VarType const& var_type = __jakt_match_value.var_type;
+ide::VarVisibility const& visibility = __jakt_match_value.visibility;
+JaktInternal::Optional<types::TypeId> const& struct_type_id = __jakt_match_value.struct_type_id;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_851; {
+DeprecatedString const result = TRY((ide::get_var_signature(program,name,type_id,mutability,var_type,visibility,struct_type_id)));
+__jakt_var_851 = static_cast<JaktInternal::Optional<DeprecatedString>>(result); goto __jakt_label_759;
+
+}
+__jakt_label_759:; __jakt_var_851.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::Call>();
+types::FunctionId const& function_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_852; {
+DeprecatedString const result = TRY((ide::get_function_signature(program,function_id)));
+__jakt_var_852 = static_cast<JaktInternal::Optional<DeprecatedString>>(result); goto __jakt_label_760;
+
+}
+__jakt_label_760:; __jakt_var_852.release_value(); }));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::Typename>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_853; {
+DeprecatedString const result = TRY((ide::get_type_signature(program,type_id)));
+__jakt_var_853 = static_cast<JaktInternal::Optional<DeprecatedString>>(result); goto __jakt_label_761;
+
+}
+__jakt_label_761:; __jakt_var_853.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename ide::Usage::NameSet>();
+JaktInternal::DynamicArray<DeprecatedString> const& names = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_854; {
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+bool first = true;
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((names).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+DeprecatedString name = (_magic_value.value());
+{
+if ((!(first))){
+(output += Jakt::DeprecatedString(" | "sv));
+}
+else {
+(first = false);
+}
+
+(output += name);
+}
+
+}
+}
+
+__jakt_var_854 = static_cast<JaktInternal::Optional<DeprecatedString>>(output); goto __jakt_label_762;
+
+}
+__jakt_label_762:; __jakt_var_854.release_value(); }));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<ide::Usage::EnumVariant>();DeprecatedString const& name = __jakt_match_value.name;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const& variants = __jakt_match_value.variants;
+JaktInternal::Optional<types::NumberConstant> const& number_constant = __jakt_match_value.number_constant;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_855; {
+DeprecatedString const result = TRY((ide::get_enum_variant_signature(program,name,type_id,variants,number_constant)));
+__jakt_var_855 = static_cast<JaktInternal::Optional<DeprecatedString>>(result); goto __jakt_label_763;
+
+}
+__jakt_label_763:; __jakt_var_855.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+else {
+return (JaktInternal::OptionalNone());
+}
+
+}
+}
+
 ErrorOr<utility::Span> find_type_definition_for_type_id(NonnullRefPtr<types::CheckedProgram> const program,types::TypeId const type_id,utility::Span const span) {
 {
 types::StructId const array_struct_id = TRY((((program)->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
@@ -2259,26 +2235,186 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-ErrorOr<DeprecatedString> get_enum_variant_signature(NonnullRefPtr<types::CheckedProgram> const program,DeprecatedString const name,types::TypeId const type_id,JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const variants,JaktInternal::Optional<types::NumberConstant> const number_constant) {
-{
-DeprecatedString output = TRY((ide::get_type_signature(program,type_id)));
-(output += Jakt::DeprecatedString("::"sv));
-(output += name);
-if ((!(((variants).is_empty())))){
-(output += Jakt::DeprecatedString("("sv));
-bool first = true;
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> _magic = ((variants).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId> variant_name__variant_type_id__ = (_magic_value.value());
+ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_statement(NonnullRefPtr<types::CheckedProgram> const program,NonnullRefPtr<typename types::CheckedStatement> const statement,utility::Span const span) {
 {
-JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId> const jakt__variant_name__variant_type_id__ = variant_name__variant_type_id__;
-JaktInternal::Optional<DeprecatedString> const variant_name = ((jakt__variant_name__variant_type_id__).template get<0>());
-types::TypeId const variant_type_id = ((jakt__variant_name__variant_type_id__).template get<1>());
+JaktInternal::Optional<ide::Usage> const none = JaktInternal::OptionalNone();
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>, ErrorOr<JaktInternal::Optional<ide::Usage>>>{
+auto&& __jakt_match_variant = *statement;
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(TRY((ide::find_span_in_block(program,block,span))));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.statement;
+return JaktInternal::ExplicitValue(TRY((ide::find_span_in_statement(program,statement,span))));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,expr,span))));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& then_block = __jakt_match_value.then_block;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_857; {
+JaktInternal::Optional<ide::Usage> found = TRY((ide::find_span_in_expression(program,condition,span)));
+if (((found).has_value())){
+return (found);
+}
+(found = TRY((ide::find_span_in_block(program,then_block,span))));
+if (((found).has_value())){
+return (found);
+}
+if (((else_statement).has_value())){
+return (TRY((ide::find_span_in_statement(program,(else_statement.value()),span))));
+}
+__jakt_var_857 = none; goto __jakt_label_765;
+
+}
+__jakt_label_765:; __jakt_var_857.release_value(); }));
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_858; {
+JaktInternal::Optional<ide::Usage> const output = JaktInternal::OptionalNone();
+__jakt_var_858 = output; goto __jakt_label_766;
+
+}
+__jakt_label_766:; __jakt_var_858.release_value(); }));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(TRY((ide::find_span_in_block(program,block,span))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
+auto __jakt_enum_value = (((val).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,(val.value()),span))));
+}
+else {
+return JaktInternal::ExplicitValue(none);
+}
+}()))
+);
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,expr,span))));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();types::VarId const& var_id = __jakt_match_value.var_id;
+NonnullRefPtr<typename types::CheckedExpression> const& init = __jakt_match_value.init;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_859; {
+NonnullRefPtr<types::CheckedVariable> const checked_var = ((program)->get_variable(var_id));
+JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,init,span)));
+if (((found).has_value())){
+return (found);
+}
+if (((((checked_var)->type_span)).has_value())){
+utility::Span const type_span = (((checked_var)->type_span).value());
+if (((type_span).contains(span))){
+return (static_cast<JaktInternal::Optional<ide::Usage>>( ide::Usage { typename ide::Usage::Typename(((checked_var)->type_id)) } ));
+}
+}
+if (((((checked_var)->definition_span)).contains(span))){
+ide::Mutability const mutability = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<ide::Mutability,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
+auto __jakt_enum_value = (((checked_var)->is_mutable));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue( ide::Mutability { typename ide::Mutability::Mutable() } );
+}
+else {
+return JaktInternal::ExplicitValue( ide::Mutability { typename ide::Mutability::Immutable() } );
+}
+}()))
+;
+return (static_cast<JaktInternal::Optional<ide::Usage>>( ide::Usage { typename ide::Usage::Variable(((checked_var)->definition_span),((checked_var)->name),((checked_var)->type_id),mutability, ide::VarType { typename ide::VarType::Variable() } , ide::VarVisibility { typename ide::VarVisibility::DoesNotApply() } ,JaktInternal::OptionalNone()) } ));
+}
+__jakt_var_859 = none; goto __jakt_label_767;
+
+}
+__jakt_label_767:; __jakt_var_859.release_value(); }));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_860; {
+JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,condition,span)));
+if (((found).has_value())){
+return (found);
+}
+__jakt_var_860 = TRY((ide::find_span_in_block(program,block,span))); goto __jakt_label_768;
+
+}
+__jakt_label_768:; __jakt_var_860.release_value(); }));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& vars = __jakt_match_value.vars;
+NonnullRefPtr<typename types::CheckedStatement> const& var_decl = __jakt_match_value.var_decl;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_861; {
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((vars).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename types::CheckedStatement> var = (_magic_value.value());
+{
+JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_statement(program,var,span)));
+if (((found).has_value())){
+return (found);
+}
+}
+
+}
+}
+
+__jakt_var_861 = TRY((ide::find_span_in_statement(program,var_decl,span))); goto __jakt_label_769;
+
+}
+__jakt_label_769:; __jakt_var_861.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,expr,span))));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(none);
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(none);
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(none);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
+ErrorOr<DeprecatedString> get_enum_variant_signature(NonnullRefPtr<types::CheckedProgram> const program,DeprecatedString const name,types::TypeId const type_id,JaktInternal::DynamicArray<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const variants,JaktInternal::Optional<types::NumberConstant> const number_constant) {
+{
+DeprecatedString output = TRY((ide::get_type_signature(program,type_id)));
+(output += Jakt::DeprecatedString("::"sv));
+(output += name);
+if ((!(((variants).is_empty())))){
+(output += Jakt::DeprecatedString("("sv));
+bool first = true;
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> _magic = ((variants).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId> variant_name__variant_type_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::TypeId> const jakt__variant_name__variant_type_id__ = variant_name__variant_type_id__;
+JaktInternal::Optional<DeprecatedString> const variant_name = ((jakt__variant_name__variant_type_id__).template get<0>());
+types::TypeId const variant_type_id = ((jakt__variant_name__variant_type_id__).template get<1>());
 
 if (first){
 (first = false);
@@ -2424,185 +2560,49 @@ return (usage);
 }
 }
 
-ErrorOr<ide::JaktSymbol> function_to_symbol(parser::ParsedFunction const function,DeprecatedString const kind) {
+ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_block(NonnullRefPtr<types::CheckedProgram> const program,types::CheckedBlock const block,utility::Span const span) {
 {
-utility::Span function_span = ((function).name_span);
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((((function).block)).stmts)).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedStatement> stmt = (_magic_value.value());
-{
-(function_span = TRY((parser::merge_spans(function_span,((stmt)->span())))));
-}
-
-}
-}
-
-return (ide::JaktSymbol(((function).name),JaktInternal::OptionalNone(),kind,function_span,((function).name_span),(TRY((DynamicArray<ide::JaktSymbol>::create_with({}))))));
-}
-}
-
-ErrorOr<JaktInternal::Optional<ide::Usage>> find_span_in_statement(NonnullRefPtr<types::CheckedProgram> const program,NonnullRefPtr<typename types::CheckedStatement> const statement,utility::Span const span) {
+NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
 {
-JaktInternal::Optional<ide::Usage> const none = JaktInternal::OptionalNone();
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>, ErrorOr<JaktInternal::Optional<ide::Usage>>>{
-auto&& __jakt_match_variant = *statement;
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(TRY((ide::find_span_in_block(program,block,span))));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.statement;
-return JaktInternal::ExplicitValue(TRY((ide::find_span_in_statement(program,statement,span))));
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,expr,span))));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& then_block = __jakt_match_value.then_block;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_857; {
-JaktInternal::Optional<ide::Usage> found = TRY((ide::find_span_in_expression(program,condition,span)));
-if (((found).has_value())){
-return (found);
-}
-(found = TRY((ide::find_span_in_block(program,then_block,span))));
+JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_statement(program,statement,span)));
 if (((found).has_value())){
 return (found);
 }
-if (((else_statement).has_value())){
-return (TRY((ide::find_span_in_statement(program,(else_statement.value()),span))));
 }
-__jakt_var_857 = none; goto __jakt_label_765;
-
-}
-__jakt_label_765:; __jakt_var_857.release_value(); }));
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_858; {
-JaktInternal::Optional<ide::Usage> const output = JaktInternal::OptionalNone();
-__jakt_var_858 = output; goto __jakt_label_766;
 
 }
-__jakt_label_766:; __jakt_var_858.release_value(); }));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(TRY((ide::find_span_in_block(program,block,span))));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<ide::Usage>,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
-auto __jakt_enum_value = (((val).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,(val.value()),span))));
-}
-else {
-return JaktInternal::ExplicitValue(none);
-}
-}()))
-);
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,expr,span))));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();types::VarId const& var_id = __jakt_match_value.var_id;
-NonnullRefPtr<typename types::CheckedExpression> const& init = __jakt_match_value.init;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_859; {
-NonnullRefPtr<types::CheckedVariable> const checked_var = ((program)->get_variable(var_id));
-JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,init,span)));
-if (((found).has_value())){
-return (found);
-}
-if (((((checked_var)->type_span)).has_value())){
-utility::Span const type_span = (((checked_var)->type_span).value());
-if (((type_span).contains(span))){
-return (static_cast<JaktInternal::Optional<ide::Usage>>( ide::Usage { typename ide::Usage::Typename(((checked_var)->type_id)) } ));
-}
-}
-if (((((checked_var)->definition_span)).contains(span))){
-ide::Mutability const mutability = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<ide::Mutability,ErrorOr<JaktInternal::Optional<ide::Usage>>>{
-auto __jakt_enum_value = (((checked_var)->is_mutable));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue( ide::Mutability { typename ide::Mutability::Mutable() } );
-}
-else {
-return JaktInternal::ExplicitValue( ide::Mutability { typename ide::Mutability::Immutable() } );
-}
-}()))
-;
-return (static_cast<JaktInternal::Optional<ide::Usage>>( ide::Usage { typename ide::Usage::Variable(((checked_var)->definition_span),((checked_var)->name),((checked_var)->type_id),mutability, ide::VarType { typename ide::VarType::Variable() } , ide::VarVisibility { typename ide::VarVisibility::DoesNotApply() } ,JaktInternal::OptionalNone()) } ));
 }
-__jakt_var_859 = none; goto __jakt_label_767;
 
+return (JaktInternal::OptionalNone());
 }
-__jakt_label_767:; __jakt_var_859.release_value(); }));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_860; {
-JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_expression(program,condition,span)));
-if (((found).has_value())){
-return (found);
 }
-__jakt_var_860 = TRY((ide::find_span_in_block(program,block,span))); goto __jakt_label_768;
 
-}
-__jakt_label_768:; __jakt_var_860.release_value(); }));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& vars = __jakt_match_value.vars;
-NonnullRefPtr<typename types::CheckedStatement> const& var_decl = __jakt_match_value.var_decl;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<ide::Usage>> __jakt_var_861; {
+ErrorOr<ide::JaktSymbol> function_to_symbol(parser::ParsedFunction const function,DeprecatedString const kind) {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((vars).iterator());
+utility::Span function_span = ((function).name_span);
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((((function).block)).stmts)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename types::CheckedStatement> var = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedStatement> stmt = (_magic_value.value());
 {
-JaktInternal::Optional<ide::Usage> const found = TRY((ide::find_span_in_statement(program,var,span)));
-if (((found).has_value())){
-return (found);
-}
+(function_span = TRY((parser::merge_spans(function_span,((stmt)->span())))));
 }
 
 }
 }
 
-__jakt_var_861 = TRY((ide::find_span_in_statement(program,var_decl,span))); goto __jakt_label_769;
-
-}
-__jakt_label_769:; __jakt_var_861.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((ide::find_span_in_expression(program,expr,span))));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(none);
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(none);
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(none);
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+return (ide::JaktSymbol(((function).name),JaktInternal::OptionalNone(),kind,function_span,((function).name_span),(TRY((DynamicArray<ide::JaktSymbol>::create_with({}))))));
 }
 }
 
@@ -2831,6 +2831,23 @@ break;}
 }
 return builder.to_string();
 }
+ErrorOr<DeprecatedString> ide::VarVisibility::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* DoesNotApply */: {
+return DeprecatedString("VarVisibility::DoesNotApply"sv);
+break;}
+case 1 /* Public */: {
+return DeprecatedString("VarVisibility::Public"sv);
+break;}
+case 2 /* Private */: {
+return DeprecatedString("VarVisibility::Private"sv);
+break;}
+case 3 /* Restricted */: {
+return DeprecatedString("VarVisibility::Restricted"sv);
+break;}
+}
+return builder.to_string();
+}
 ErrorOr<DeprecatedString> ide::Usage::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
 switch (this->index()) {case 0 /* Variable */: {
@@ -2914,22 +2931,5 @@ break;}
 }
 return builder.to_string();
 }
-ErrorOr<DeprecatedString> ide::VarVisibility::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* DoesNotApply */: {
-return DeprecatedString("VarVisibility::DoesNotApply"sv);
-break;}
-case 1 /* Public */: {
-return DeprecatedString("VarVisibility::Public"sv);
-break;}
-case 2 /* Private */: {
-return DeprecatedString("VarVisibility::Private"sv);
-break;}
-case 3 /* Restricted */: {
-return DeprecatedString("VarVisibility::Restricted"sv);
-break;}
-}
-return builder.to_string();
-}
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/ide.h b/bootstrap/stage0/ide.h
index 9546b3d24..44c7e671a 100644
--- a/bootstrap/stage0/ide.h
+++ b/bootstrap/stage0/ide.h
@@ -6,7 +6,13 @@
 #include "compiler.h"
 namespace Jakt {
 namespace ide {
-namespace Mutability_Details {
+struct JaktSymbol {
+  public:
+DeprecatedString name;JaktInternal::Optional<DeprecatedString> detail;DeprecatedString kind;utility::Span range;utility::Span selection_range;JaktInternal::DynamicArray<ide::JaktSymbol> children;JaktSymbol(DeprecatedString a_name, JaktInternal::Optional<DeprecatedString> a_detail, DeprecatedString a_kind, utility::Span a_range, utility::Span a_selection_range, JaktInternal::DynamicArray<ide::JaktSymbol> a_children);
+
+ErrorOr<DeprecatedString> to_json() const;
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace Mutability_Details {
 struct DoesNotApply {
 };
 struct Immutable {
@@ -117,13 +123,13 @@ using Variant<Usage_Details::Variable, Usage_Details::Call, Usage_Details::Typen
     using EnumVariant = Usage_Details::EnumVariant;
 ErrorOr<DeprecatedString> debug_description() const;
 };
-struct JaktSymbol {
-  public:
-DeprecatedString name;JaktInternal::Optional<DeprecatedString> detail;DeprecatedString kind;utility::Span range;utility::Span selection_range;JaktInternal::DynamicArray<ide::JaktSymbol> children;JaktSymbol(DeprecatedString a_name, JaktInternal::Optional<DeprecatedString> a_detail, DeprecatedString a_kind, utility::Span a_range, utility::Span a_selection_range, JaktInternal::DynamicArray<ide::JaktSymbol> a_children);
-
-ErrorOr<DeprecatedString> to_json() const;
-ErrorOr<DeprecatedString> debug_description() const;
-};}
+}
+} // namespace Jakt
+template<>struct Jakt::Formatter<Jakt::ide::JaktSymbol> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::ide::JaktSymbol const& value) {
+JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
+};
+namespace Jakt {
 } // namespace Jakt
 template<>struct Jakt::Formatter<Jakt::ide::Mutability> : Jakt::Formatter<Jakt::StringView>{
 Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::ide::Mutability const& value) {
@@ -149,9 +155,3 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::ide::JaktSymbol> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::ide::JaktSymbol const& value) {
-JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
-};
-namespace Jakt {
-} // namespace Jakt
diff --git a/bootstrap/stage0/interpreter.cpp b/bootstrap/stage0/interpreter.cpp
index 13b6b52d7..25e01a345 100644
--- a/bootstrap/stage0/interpreter.cpp
+++ b/bootstrap/stage0/interpreter.cpp
@@ -1,130 +1,6 @@
 #include "interpreter.h"
 namespace Jakt {
 namespace interpreter {
-ErrorOr<DeprecatedString> comptime_format_impl(DeprecatedString const format_string,JaktInternal::ArraySlice<types::Value> const arguments,NonnullRefPtr<interpreter::Interpreter> const interpreter) {
-{
-DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
-size_t current_argument_index = static_cast<size_t>(0ULL);
-DeprecatedStringBuilder format_field_builder = TRY((DeprecatedStringBuilder::create()));
-JaktInternal::Optional<size_t> index_in_field = JaktInternal::OptionalNone();
-bool expect_close_brace = false;
-Function<JaktInternal::Tuple<JaktInternal::Optional<size_t>,DeprecatedString>(DeprecatedString)> const argument_and_index = [](DeprecatedString str) -> JaktInternal::Tuple<JaktInternal::Optional<size_t>,DeprecatedString> {
-{
-size_t slice_end = static_cast<size_t>(0ULL);
-bool has_index = false;
-{
-DeprecatedStringCodePointIterator _magic = ((str).code_points());
-for (;;){
-JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-u32 code_point = (_magic_value.value());
-{
-if (((code_point >= static_cast<u32>(U'0')) && (code_point <= static_cast<u32>(U'9')))){
-({auto& _jakt_ref = slice_end;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
-(has_index = true);
-}
-else {
-break;
-}
-
-}
-
-}
-}
-
-if (has_index){
-DeprecatedString const index_str = ((str).substring(static_cast<size_t>(0ULL),slice_end));
-JaktInternal::Optional<u32> const index = ((index_str).to_uint());
-if (((index).has_value())){
-return ((Tuple{static_cast<JaktInternal::Optional<size_t>>((infallible_integer_cast<size_t>(((index.value()))))), ((str).substring(slice_end,(JaktInternal::checked_sub<size_t>(((str).length()),slice_end))))}));
-}
-}
-return ((Tuple{static_cast<JaktInternal::Optional<size_t>>(JaktInternal::OptionalNone()), str}));
-}
-}
-;
-{
-DeprecatedStringCodePointIterator _magic = ((format_string).code_points());
-for (;;){
-JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-u32 code_point = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (code_point);
-if (__jakt_enum_value == static_cast<u32>(U'{')) {
-{
-if ((((index_in_field).has_value()) && ((index_in_field.value()) == static_cast<size_t>(0ULL)))){
-TRY((((builder).append_code_point(static_cast<u32>(U'{')))));
-(index_in_field = JaktInternal::OptionalNone());
-}
-else if (((index_in_field).has_value())){
-TRY((((format_field_builder).append_code_point(static_cast<u32>(U'{')))));
-(index_in_field = (JaktInternal::checked_add<size_t>((index_in_field.value()),static_cast<size_t>(1ULL))));
-}
-else {
-(index_in_field = static_cast<size_t>(0ULL));
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == static_cast<u32>(U'}')) {
-{
-if (expect_close_brace){
-TRY((((builder).append_code_point(static_cast<u32>(U'}')))));
-(expect_close_brace = false);
-}
-else if ((!(((index_in_field).has_value())))){
-(expect_close_brace = true);
-}
-else {
-(index_in_field = JaktInternal::OptionalNone());
-DeprecatedString const fmt_string = TRY((((format_field_builder).to_string())));
-((format_field_builder).clear());
-JaktInternal::Tuple<JaktInternal::Optional<size_t>,DeprecatedString> const index_format_string_ = argument_and_index(fmt_string);
-JaktInternal::Optional<size_t> const index = ((index_format_string_).template get<0>());
-DeprecatedString const format_string = ((index_format_string_).template get<1>());
-
-size_t const effective_index = index.value_or_lazy_evaluated([&] { return ((current_argument_index++)); });
-if ((effective_index >= ((arguments).size()))){
-return Error::__jakt_from_string_literal((StringView::from_string_literal("Not enough arguments for format string"sv)));
-}
-DeprecatedString const effective_format_string = TRY((__jakt_format(Jakt::DeprecatedString("{{{}}}"sv),format_string)));
-TRY((((builder).append(TRY((interpreter::format_value_impl(effective_format_string,((arguments)[effective_index]),interpreter)))))));
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-if (((index_in_field).has_value())){
-TRY((((format_field_builder).append_code_point(code_point))));
-}
-else {
-TRY((((builder).append_code_point(code_point))));
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-}
-
-}
-}
-
-return (TRY((((builder).to_string()))));
-}
-}
-
 ErrorOr<size_t> align_of_impl(types::TypeId const type_id,NonnullRefPtr<interpreter::Interpreter> const interpreter) {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<size_t>>{
@@ -2558,1146 +2434,1104 @@ return Error::__jakt_from_string_literal((StringView::from_string_literal("Canno
 }
 }
 
-ErrorOr<DeprecatedString> interpreter::Interpreter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Interpreter("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("program: {}, ", *program));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("spans: {}, ", spans));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("reflected_type_cache: {}, ", reflected_type_cache));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("seen_reflected_types: {}, ", seen_reflected_types));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("current_function_id: {}, ", current_function_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("typecheck_functions: {}", *typecheck_functions));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<void> interpreter::Interpreter::update_binding(NonnullRefPtr<typename types::CheckedExpression> const binding,NonnullRefPtr<interpreter::InterpreterScope> scope,types::Value const value,utility::Span const span) {
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = *binding;
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
+ErrorOr<DeprecatedString> comptime_format_impl(DeprecatedString const format_string,JaktInternal::ArraySlice<types::Value> const arguments,NonnullRefPtr<interpreter::Interpreter> const interpreter) {
 {
-TRY((((scope)->set(((var)->name),value))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-DeprecatedString const& index = __jakt_match_value.index;
+DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+size_t current_argument_index = static_cast<size_t>(0ULL);
+DeprecatedStringBuilder format_field_builder = TRY((DeprecatedStringBuilder::create()));
+JaktInternal::Optional<size_t> index_in_field = JaktInternal::OptionalNone();
+bool expect_close_brace = false;
+Function<JaktInternal::Tuple<JaktInternal::Optional<size_t>,DeprecatedString>(DeprecatedString)> const argument_and_index = [](DeprecatedString str) -> JaktInternal::Tuple<JaktInternal::Optional<size_t>,DeprecatedString> {
 {
-JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::StructId> fields_struct_id_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::StructId>, ErrorOr<void>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::StructId>, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Class>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::StructId const& struct_id = __jakt_match_value.struct_id;
-return JaktInternal::ExplicitValue((Tuple{fields, struct_id}));
-};/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::StructId const& struct_id = __jakt_match_value.struct_id;
-return JaktInternal::ExplicitValue((Tuple{fields, struct_id}));
-};/*case end*/
-default: {
+size_t slice_end = static_cast<size_t>(0ULL);
+bool has_index = false;
 {
-utility::panic(Jakt::DeprecatedString("Invalid left-hand side in assignment"sv));
+DeprecatedStringCodePointIterator _magic = ((str).code_points());
+for (;;){
+JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-default: {
+u32 code_point = (_magic_value.value());
 {
-utility::panic(Jakt::DeprecatedString("Should not be happening here"sv));
+if (((code_point >= static_cast<u32>(U'0')) && (code_point <= static_cast<u32>(U'9')))){
+({auto& _jakt_ref = slice_end;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+(has_index = true);
+}
+else {
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<types::Value> fields = ((fields_struct_id_).template get<0>());
-types::StructId struct_id = ((fields_struct_id_).template get<1>());
 
-JaktInternal::DynamicArray<types::CheckedField> const field_decls = ((((((*this).program))->get_struct(struct_id))).fields);
-size_t field_index = static_cast<size_t>(0ULL);
+}
+
+}
+}
+
+if (has_index){
+DeprecatedString const index_str = ((str).substring(static_cast<size_t>(0ULL),slice_end));
+JaktInternal::Optional<u32> const index = ((index_str).to_uint());
+if (((index).has_value())){
+return ((Tuple{static_cast<JaktInternal::Optional<size_t>>((infallible_integer_cast<size_t>(((index.value()))))), ((str).substring(slice_end,(JaktInternal::checked_sub<size_t>(((str).length()),slice_end))))}));
+}
+}
+return ((Tuple{static_cast<JaktInternal::Optional<size_t>>(JaktInternal::OptionalNone()), str}));
+}
+}
+;
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((field_decls).size()))});
+DeprecatedStringCodePointIterator _magic = ((format_string).code_points());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+u32 code_point = (_magic_value.value());
 {
-if ((((((((*this).program))->get_variable(((((field_decls)[i])).variable_id))))->name) == index)){
-(field_index = i);
-break;
-}
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (code_point);
+if (__jakt_enum_value == static_cast<u32>(U'{')) {
+{
+if ((((index_in_field).has_value()) && ((index_in_field.value()) == static_cast<size_t>(0ULL)))){
+TRY((((builder).append_code_point(static_cast<u32>(U'{')))));
+(index_in_field = JaktInternal::OptionalNone());
 }
-
+else if (((index_in_field).has_value())){
+TRY((((format_field_builder).append_code_point(static_cast<u32>(U'{')))));
+(index_in_field = (JaktInternal::checked_add<size_t>((index_in_field.value()),static_cast<size_t>(1ULL))));
 }
+else {
+(index_in_field = static_cast<size_t>(0ULL));
 }
 
-(((fields)[field_index]) = value);
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-DeprecatedString const& index = __jakt_match_value.index;
+}
+else if (__jakt_enum_value == static_cast<u32>(U'}')) {
 {
-JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::EnumId> fields_enum_id_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::EnumId>, ErrorOr<void>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::EnumId>, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::EnumId const& enum_id = __jakt_match_value.enum_id;
-return JaktInternal::ExplicitValue((Tuple{fields, enum_id}));
-};/*case end*/
-default: {
+if (expect_close_brace){
+TRY((((builder).append_code_point(static_cast<u32>(U'}')))));
+(expect_close_brace = false);
+}
+else if ((!(((index_in_field).has_value())))){
+(expect_close_brace = true);
+}
+else {
+(index_in_field = JaktInternal::OptionalNone());
+DeprecatedString const fmt_string = TRY((((format_field_builder).to_string())));
+((format_field_builder).clear());
+JaktInternal::Tuple<JaktInternal::Optional<size_t>,DeprecatedString> const index_format_string_ = argument_and_index(fmt_string);
+JaktInternal::Optional<size_t> const index = ((index_format_string_).template get<0>());
+DeprecatedString const format_string = ((index_format_string_).template get<1>());
+
+size_t const effective_index = index.value_or_lazy_evaluated([&] { return ((current_argument_index++)); });
+if ((effective_index >= ((arguments).size()))){
+return Error::__jakt_from_string_literal((StringView::from_string_literal("Not enough arguments for format string"sv)));
+}
+DeprecatedString const effective_format_string = TRY((__jakt_format(Jakt::DeprecatedString("{{{}}}"sv),format_string)));
+TRY((((builder).append(TRY((interpreter::format_value_impl(effective_format_string,((arguments)[effective_index]),interpreter)))))));
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else {
 {
-utility::panic(Jakt::DeprecatedString("Invalid left-hand side in assignment"sv));
+if (((index_in_field).has_value())){
+TRY((((format_field_builder).append_code_point(code_point))));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-default: {
+else {
+TRY((((builder).append_code_point(code_point))));
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+}
+
+}
+}
+
+return (TRY((((builder).to_string()))));
+}
+}
+
+ErrorOr<DeprecatedString> interpreter::InterpreterScope::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("InterpreterScope("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("bindings: {}, ", bindings));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parent: {}, ", parent));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_bindings: {}, ", type_bindings));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("defers: {}", defers));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<void> interpreter::InterpreterScope::set(DeprecatedString const name,types::Value const value) {
 {
-utility::panic(Jakt::DeprecatedString("Should not be happening here"sv));
+if (((((*this).bindings)).contains(name))){
+TRY(((*this).bindings).set(name, value));
+return {};
+}
+JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> scope = ((*this).parent);
+while (((scope).has_value())){
+if ((((((scope.value()))->bindings)).contains(name))){
+TRY((((scope.value()))->bindings).set(name, value));
+return {};
+}
+(scope = (((scope.value()))->parent));
+}
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::UnknownVariable))));
+}
+return {};
+}
+
+ErrorOr<NonnullRefPtr<interpreter::InterpreterScope>> interpreter::InterpreterScope::create(JaktInternal::Dictionary<DeprecatedString,types::Value> const bindings,JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const parent,JaktInternal::Dictionary<DeprecatedString,types::TypeId> const type_bindings) {
+{
+return (TRY((interpreter::InterpreterScope::__jakt_create(bindings,parent,type_bindings,(TRY((DynamicArray<interpreter::Deferred>::create_with({}))))))));
 }
+}
+
+ErrorOr<void> interpreter::InterpreterScope::defer_statement(NonnullRefPtr<typename types::CheckedStatement> const statement) {
+{
+TRY((((((*this).defers)).push( interpreter::Deferred { typename interpreter::Deferred::Statement(statement) } ))));
+}
+return {};
+}
+
+ErrorOr<void> interpreter::InterpreterScope::perform_defers(NonnullRefPtr<interpreter::Interpreter> interpreter,utility::Span const span) {
+{
+while ((!(((((*this).defers)).is_empty())))){
+JaktInternal::Optional<interpreter::Deferred> const deferred = ((((*this).defers)).pop());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<void>>{
+auto&& __jakt_match_variant = (deferred.value());
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::Deferred::Expression>();
+NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((interpreter)->execute_expression(expr,*this)))));
 };/*case end*/
-}/*switch end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::Deferred::Statement>();
+NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((interpreter)->execute_statement(statement,*this,span)))));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-JaktInternal::DynamicArray<types::Value> fields = ((fields_enum_id_).template get<0>());
-types::EnumId enum_id = ((fields_enum_id_).template get<1>());
+}
+}
+return {};
+}
 
-JaktInternal::DynamicArray<types::CheckedField> const field_decls = ((((((*this).program))->get_enum(enum_id))).fields);
-size_t field_index = static_cast<size_t>(0ULL);
+ErrorOr<NonnullRefPtr<interpreter::InterpreterScope>> interpreter::InterpreterScope::from_runtime_scope(types::ScopeId const scope_id,NonnullRefPtr<types::CheckedProgram> const program,JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const parent) {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((field_decls).size()))});
+JaktInternal::Dictionary<DeprecatedString,types::Value> bindings = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
+JaktInternal::Optional<types::ScopeId> current_id = scope_id;
+while (((current_id).has_value())){
+NonnullRefPtr<types::Scope> const scope = TRY((((program)->get_scope((current_id.value())))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::Value> _magic = ((((scope)->comptime_bindings)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::Value>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::Value> pair = (_magic_value.value());
 {
-if ((((((((*this).program))->get_variable(((((field_decls)[i])).variable_id))))->name) == index)){
-(field_index = i);
-break;
+if (((bindings).contains(((pair).template get<0>())))){
+continue;
 }
+TRY((((bindings).set(((pair).template get<0>()),((pair).template get<1>())))));
 }
 
 }
 }
 
-(((fields)[field_index]) = value);
+(current_id = ((scope)->parent));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+return (TRY((interpreter::InterpreterScope::__jakt_create(bindings,parent,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))),(TRY((DynamicArray<interpreter::Deferred>::create_with({}))))))));
+}
+}
+
+ErrorOr<JaktInternal::Dictionary<DeprecatedString,types::Value>> interpreter::InterpreterScope::all_bindings() const {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid left-hand side of assignment {}"sv),binding))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+JaktInternal::Dictionary<DeprecatedString,types::Value> bindings = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
+JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> scope = static_cast<JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>>>(*this);
+while (((scope).has_value())){
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::Value> _magic = (((((scope.value()))->bindings)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::Value>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+JaktInternal::Tuple<DeprecatedString,types::Value> pair = (_magic_value.value());
+{
+if (((bindings).contains(((pair).template get<0>())))){
+continue;
 }
-return {};
+TRY((((bindings).set(((pair).template get<0>()),((pair).template get<1>())))));
 }
 
-interpreter::Interpreter::Interpreter(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, JaktInternal::DynamicArray<utility::Span> a_spans, JaktInternal::Dictionary<DeprecatedString,types::Value> a_reflected_type_cache, JaktInternal::Set<DeprecatedString> a_seen_reflected_types, JaktInternal::Optional<types::FunctionId> a_current_function_id, NonnullRefPtr<types::TypecheckFunctions> a_typecheck_functions): compiler(move(a_compiler)), program(move(a_program)), spans(move(a_spans)), reflected_type_cache(move(a_reflected_type_cache)), seen_reflected_types(move(a_seen_reflected_types)), current_function_id(move(a_current_function_id)), typecheck_functions(move(a_typecheck_functions)){}
-ErrorOr<NonnullRefPtr<Interpreter>> interpreter::Interpreter::__jakt_create(NonnullRefPtr<compiler::Compiler> compiler, NonnullRefPtr<types::CheckedProgram> program, JaktInternal::DynamicArray<utility::Span> spans, JaktInternal::Dictionary<DeprecatedString,types::Value> reflected_type_cache, JaktInternal::Set<DeprecatedString> seen_reflected_types, JaktInternal::Optional<types::FunctionId> current_function_id, NonnullRefPtr<types::TypecheckFunctions> typecheck_functions) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Interpreter (move(compiler), move(program), move(spans), move(reflected_type_cache), move(seen_reflected_types), move(current_function_id), move(typecheck_functions)))); return o; }
-ErrorOr<types::CheckedBlock> interpreter::Interpreter::typecheck_block(parser::ParsedBlock const block,types::ScopeId const scope) {
-{
-return (TRY((interpreter::Interpreter::invoke_typecheck_block(((((((*this).typecheck_functions))->block))),block,scope))));
 }
 }
 
-ErrorOr<types::Value> interpreter::Interpreter::reflect_methods(utility::Span const span) {
+(scope = (((scope.value()))->parent));
+}
+return (bindings);
+}
+}
+
+ErrorOr<void> interpreter::InterpreterScope::type_map_for_substitution_helper(JaktInternal::Dictionary<DeprecatedString,DeprecatedString>& map) const {
 {
-types::StructId const method_struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::StructId, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Method"sv)))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(id);
-};/*case end*/
-default: {
+if (((((*this).parent)).has_value())){
+TRY(((((((*this).parent).value()))->type_map_for_substitution_helper(map))));
+}
 {
-utility::panic(Jakt::DeprecatedString("Expected Method to be a struct"sv));
+JaktInternal::DictionaryIterator<DeprecatedString,types::TypeId> _magic = ((((*this).type_bindings)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::TypeId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-types::FunctionId const method_struct_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_struct(method_struct_id))).scope_id),Jakt::DeprecatedString("Method"sv))))).value());
-JaktInternal::DynamicArray<types::Value> method_values = (TRY((DynamicArray<types::Value>::create_with({}))));
-return (types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(method_values,TRY((((*this).array_type_of_struct(method_struct_id))))))),span));
+JaktInternal::Tuple<DeprecatedString,types::TypeId> pair = (_magic_value.value());
+{
+TRY((((((map))).set(((pair).template get<0>()),TRY((((((pair).template get<1>())).to_string())))))));
+}
+
 }
 }
 
-ErrorOr<types::Value> interpreter::Interpreter::string_value(DeprecatedString const string,utility::Span const span) {
+}
+return {};
+}
+
+ErrorOr<types::GenericInferences> interpreter::InterpreterScope::type_map_for_substitution() const {
 {
-return (types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(string))),span));
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> map = (TRY((Dictionary<DeprecatedString, DeprecatedString>::create_with_entries({}))));
+TRY((((*this).type_map_for_substitution_helper(((map))))));
+return (types::GenericInferences(map));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> interpreter::Interpreter::perform_final_interpretation_expr_pass(NonnullRefPtr<typename types::CheckedExpression> const expr,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
+interpreter::InterpreterScope::InterpreterScope(JaktInternal::Dictionary<DeprecatedString,types::Value> a_bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> a_parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> a_type_bindings, JaktInternal::DynamicArray<interpreter::Deferred> a_defers): bindings(move(a_bindings)), parent(move(a_parent)), type_bindings(move(a_type_bindings)), defers(move(a_defers)){}
+ErrorOr<NonnullRefPtr<InterpreterScope>> interpreter::InterpreterScope::__jakt_create(JaktInternal::Dictionary<DeprecatedString,types::Value> bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings, JaktInternal::DynamicArray<interpreter::Deferred> defers) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) InterpreterScope (move(bindings), move(parent), move(type_bindings), move(defers)))); return o; }
+ErrorOr<void> interpreter::InterpreterScope::defer_expression(NonnullRefPtr<typename types::CheckedExpression> const expr) {
 {
-if (((expr)->index() == 6 /* UnaryOp */)){
-types::CheckedUnaryOperator const op = ((expr)->get<types::CheckedExpression::UnaryOp>()).op;
-if (((op).index() == 11 /* TypeCast */)){
-warnln(Jakt::DeprecatedString("{0:c}[31mFixup{0:c}[0m {1}"sv),static_cast<i64>(27LL),expr);
+TRY((((((*this).defers)).push( interpreter::Deferred { typename interpreter::Deferred::Expression(expr) } ))));
 }
+return {};
 }
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *expr;
-switch(__jakt_match_variant.index()) {
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ComptimeIndex>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-NonnullRefPtr<typename types::CheckedExpression> const& index = __jakt_match_value.index;
-bool const& is_optional = __jakt_match_value.is_optional;
-utility::Span const& span = __jakt_match_value.span;
+
+ErrorOr<types::Value> interpreter::InterpreterScope::must_get(DeprecatedString const name) const {
 {
-interpreter::StatementResult const index_result = TRY((((*this).execute_expression(index,scope))));
-types::NumericOrStringValue const index_constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::NumericOrStringValue, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = index_result;
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::NumericOrStringValue, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::StringValue(val) } );
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index expression evaluation failed: expected numeric or string type, found {}"sv),((value).impl)))),span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
+if (((((*this).bindings)).contains(name))){
+return (((((*this).bindings))[name]));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index expression evaluation returned an invalid object {}"sv),index_result))),span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
+JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> scope = ((*this).parent);
+while (((scope).has_value())){
+if ((((((scope.value()))->bindings)).contains(name))){
+return ((((((scope.value()))->bindings))[name]));
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = index_constant;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumericOrStringValue::StringValue>();
-DeprecatedString const& field = __jakt_match_value.value;
-{
-types::TypeId const checked_expr_type_id = TRY((((scope)->map_type(((expr)->type())))));
-NonnullRefPtr<typename types::Type> const checked_expr_type = ((((*this).program))->get_type(checked_expr_type_id));
-types::StructId const optional_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *checked_expr_type;
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-{
-types::TypeId type_id = checked_expr_type_id;
-if (is_optional){
-if ((!(((id).equals(optional_struct_id))))){
-TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is only allowed on optional types"sv),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+(scope = (((scope.value()))->parent));
 }
-(type_id = ((args)[static_cast<i64>(0LL)]));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::UnknownVariable))));
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
-{
-types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
-{
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::CheckedField member_id = (_magic_value.value());
+
+ErrorOr<types::TypeId> interpreter::InterpreterScope::map_type(types::TypeId const id) const {
 {
-NonnullRefPtr<types::CheckedVariable> const member = ((((*this).program))->get_variable(((member_id).variable_id)));
-if ((((member)->name) == field)){
-types::TypeId resolved_type_id = TRY((((scope)->map_type(((member)->type_id)))));
-if (is_optional){
-(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+DeprecatedString const name = TRY((((id).to_string())));
+if (((((*this).type_bindings)).contains(name))){
+return (((((*this).type_bindings))[name]));
 }
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(expr,field,span,is_optional,resolved_type_id))));
+JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> scope = ((*this).parent);
+while (((scope).has_value())){
+if ((((((scope.value()))->type_bindings)).contains(name))){
+return ((((((scope.value()))->type_bindings))[name]));
 }
+(scope = (((scope.value()))->parent));
 }
-
+return (id);
 }
 }
 
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+ErrorOr<DeprecatedString> interpreter::Interpreter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Interpreter("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("program: {}, ", *program));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("spans: {}, ", spans));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("reflected_type_cache: {}, ", reflected_type_cache));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("seen_reflected_types: {}, ", seen_reflected_types));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("current_function_id: {}, ", current_function_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("typecheck_functions: {}", *typecheck_functions));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<interpreter::ExecutionResult> interpreter::Interpreter::execute(types::FunctionId const function_to_run_id,JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> namespace_,JaktInternal::Optional<types::Value> const this_argument,JaktInternal::DynamicArray<types::Value> const arguments,utility::Span const call_span,JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const invocation_scope) {
 {
-types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
+NonnullRefPtr<types::CheckedFunction> const function_to_run = ((((*this).program))->get_function(function_to_run_id));
+TRY((((*this).enter_span(call_span))));
+JaktInternal::Optional<types::FunctionId> const old_function_id = ((*this).current_function_id);
+(((*this).current_function_id) = function_to_run_id);
+ScopeGuard __jakt_var_195([&] {
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(((*this).current_function_id) = old_function_id);
+((*this).leave_span());
 }
-types::CheckedField member_id = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const member = ((((*this).program))->get_variable(((member_id).variable_id)));
-if ((((member)->name) == field)){
-types::TypeId resolved_type_id = TRY((((scope)->map_type(((member)->type_id)))));
-if (is_optional){
-(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+
+});
+bool is_prelude_function = false;
+if (((((function_to_run)->linkage)).index() == 1 /* External */)){
+NonnullRefPtr<types::Scope> const function_scope = TRY((((((*this).program))->get_scope(((function_to_run)->function_scope_id)))));
+if ((!(TRY((((*this).get_prelude_function(((function_to_run)->function_scope_id)))))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot call external function '{}'"sv),((function_to_run)->name)))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::CallToExternalFunction))));
 }
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(expr,field,span,is_optional,resolved_type_id))));
+(is_prelude_function = true);
+}
+if ((((function_to_run)->is_static()) == ((this_argument).has_value()))){
+DeprecatedString expected = Jakt::DeprecatedString("did not expect"sv);
+if ((!(((function_to_run)->is_static())))){
+(expected = Jakt::DeprecatedString("expected"sv));
 }
+DeprecatedString not_provided = Jakt::DeprecatedString(" not"sv);
+if (((this_argument).has_value())){
+(not_provided = Jakt::DeprecatedString(""sv));
 }
-
+TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::Message(TRY((__jakt_format(Jakt::DeprecatedString("function call {} a this argument, yet one was{} provided"sv),expected,not_provided))),((function_to_run)->name_span)) } ))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidThisArgument))));
 }
+size_t this_offset = static_cast<size_t>(0ULL);
+if (((this_argument).has_value())){
+(this_offset = static_cast<size_t>(1ULL));
 }
-
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+if (((JaktInternal::checked_sub<size_t>(((((function_to_run)->params)).size()),this_offset)) != ((arguments).size()))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Function called with wrong number of arguments, expected {} but got {}"sv),((((function_to_run)->params)).size()),((arguments).size())))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::MismatchingArguments))));
+}
+if (is_prelude_function){
+if ((((this_argument).has_value()) && ((!(((namespace_).has_value()))) || (((namespace_.value())).is_empty())))){
+JaktInternal::DynamicArray<types::ResolvedNamespace> effective_namespace = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+{
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("String"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();types::TypeId const& type_id = __jakt_match_value.type_id;
+{
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(args);
+};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Member field access on value of non-struct type ‘{}’"sv),TRY((((((*this).program))->type_name(checked_expr_type_id,false))))))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic array"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Array"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();types::TypeId const& type_id = __jakt_match_value.type_id;
 {
-if (is_optional){
-TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on non-optional types"sv),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
-}
-types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(args);
+};/*case end*/
+default: {
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic dictionary"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-types::CheckedField member_id = (_magic_value.value());
+};/*case end*/
+}/*switch end*/
+}()
+));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Dictionary"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();types::TypeId const& type_id = __jakt_match_value.type_id;
 {
-NonnullRefPtr<types::CheckedVariable> const member = ((((*this).program))->get_variable(((member_id).variable_id)));
-if ((((member)->name) == field)){
-types::TypeId const resolved_type_id = TRY((((scope)->map_type(((member)->type_id)))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(expr,field,span,is_optional,resolved_type_id))));
+if (((((((*this).program))->get_type(type_id)))->index() == 19 /* GenericInstance */)){
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = ((((((*this).program))->get_type(type_id)))->get<types::Type::GenericInstance>()).args;
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Set"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic set"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();types::StructId const& struct_id = __jakt_match_value.struct_id;
+{
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_struct(struct_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
 }
-
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Class>();types::StructId const& struct_id = __jakt_match_value.struct_id;
+{
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_struct(struct_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Member field access on value of non-struct type ‘{}’"sv),TRY((((((*this).program))->type_name(checked_expr_type_id,false))))))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_enum(enum_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
+case 25: {
+{
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Optional"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumericOrStringValue::UnsignedNumericValue>();
-u64 const& val = __jakt_match_value.value;
+case 24: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Unimplemented expression"sv),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Optional"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumericOrStringValue::SignedNumericValue>();
-i64 const& val = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Unimplemented expression"sv),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to call an instance method on a non-struct/enum type"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 ));
+(namespace_ = effective_namespace);
 }
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedUnaryOperator const& op = __jakt_match_value.op;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedUnaryOperator, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::TypeCast>();
-types::CheckedTypeCast const& cast = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::TypeCast(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedTypeCast, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = cast;
+JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings = (TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({}))));
+if (((invocation_scope).has_value())){
+(type_bindings = (((invocation_scope.value()))->type_bindings));
+}
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::ExecutionResult, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = TRY((((*this).call_prelude_function(((function_to_run)->name),(namespace_.value()),this_argument,arguments,call_span,type_bindings))));
 switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(value) } );
+};/*case end*/
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Fallible>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::CheckedTypeCast { typename types::CheckedTypeCast::Fallible(TRY((((scope)->map_type(type_id))))) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(value) } );
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Infallible>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::CheckedTypeCast { typename types::CheckedTypeCast::Infallible(TRY((((scope)->map_type(type_id))))) } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-))) } );
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(op);
-};/*case end*/
-}/*switch end*/
-}()
-)),span,TRY((((scope)->map_type(type_id))))))));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& lhs = __jakt_match_value.lhs;
-parser::BinaryOperator const& op = __jakt_match_value.op;
-NonnullRefPtr<typename types::CheckedExpression> const& rhs = __jakt_match_value.rhs;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::BinaryOp>(TRY((((*this).perform_final_interpretation_expr_pass(lhs,scope)))),op,TRY((((*this).perform_final_interpretation_expr_pass(rhs,scope)))),span,TRY((((scope)->map_type(type_id))))))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Throw(value) } );
 };/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_195; {
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> new_args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
+case 3: {
 {
-TRY((((new_args).push((Tuple{((arg).template get<0>()), TRY((((*this).perform_final_interpretation_expr_pass(((arg).template get<1>()),scope))))})))));
-}
-
-}
-}
-
-__jakt_var_195 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Call>(types::CheckedCall(((call).namespace_),((call).name),new_args,((call).type_args),((call).function_id),((call).return_type),((call).callee_throws),JaktInternal::OptionalNone()),span,type_id))); goto __jakt_label_183;
-
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-__jakt_label_183:; __jakt_var_195.release_value(); }));
 };/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedCall const& call = __jakt_match_value.call;
-utility::Span const& span = __jakt_match_value.span;
-bool const& is_optional = __jakt_match_value.is_optional;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_196; {
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> new_args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
+case 4: {
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
+};/*case end*/
+case 2: {
 {
-TRY((((new_args).push((Tuple{((arg).template get<0>()), TRY((((*this).perform_final_interpretation_expr_pass(((arg).template get<1>()),scope))))})))));
-}
-
-}
-}
-
-__jakt_var_196 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::MethodCall>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),types::CheckedCall(((call).namespace_),((call).name),new_args,((call).type_args),((call).function_id),((call).return_type),((call).callee_throws),JaktInternal::OptionalNone()),span,is_optional,type_id))); goto __jakt_label_184;
-
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-__jakt_label_184:; __jakt_var_196.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(expr);
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
 }
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = ((function_to_run)->type);
+switch(__jakt_match_variant.index()) {
+case 0: {
+{
+NonnullRefPtr<interpreter::InterpreterScope> scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),invocation_scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
+ScopeGuard __jakt_var_196([&] {
+{
+MUST((((scope)->perform_defers(*this,call_span))));
 }
 
-ErrorOr<types::CheckedBlock> interpreter::Interpreter::perform_final_interpretation_pass(types::CheckedBlock const block,JaktInternal::Optional<types::ScopeId> const runtime_scope,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
-{
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+});
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((function_to_run)->params)).size()))});
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-NonnullRefPtr<typename types::CheckedStatement> const new_statement = TRY((((*this).perform_final_interpretation_pass(statement,scope))));
-TRY((((statements).push(new_statement))));
-}
-
+if (((this_offset != static_cast<size_t>(0ULL)) && (i == static_cast<size_t>(0ULL)))){
+continue;
 }
+DeprecatedString const param_name = ((((((((function_to_run)->params))[i])).variable))->name);
+types::Value const param_value = ((arguments)[(JaktInternal::checked_sub<size_t>(i,this_offset))]);
+TRY(((scope)->bindings).set(param_name, param_value));
 }
 
-return (types::CheckedBlock(statements,((block).scope_id),((block).control_flow),((block).yielded_type),((block).yielded_none)));
 }
 }
 
-ErrorOr<types::CheckedBlock> interpreter::Interpreter::perform_final_interpretation_pass(parser::ParsedBlock const block,types::ScopeId const runtime_scope,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
-{
-NonnullRefPtr<types::Scope> rscope = TRY((((((*this).program))->get_scope(runtime_scope))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::Value> _magic = ((TRY((((scope)->all_bindings())))).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::Value>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((this_argument).has_value())){
+TRY((((((scope)->bindings)).set(Jakt::DeprecatedString("this"sv),(this_argument.value())))));
 }
-JaktInternal::Tuple<DeprecatedString,types::Value> name__value__ = (_magic_value.value());
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::ExecutionResult, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_block(((function_to_run)->block),scope,call_span))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(TRY((interpreter::cast_value_to_type(value,((function_to_run)->return_type_id),*this,false)))) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(TRY((interpreter::cast_value_to_type(value,((function_to_run)->return_type_id),*this,false)))) } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Throw(value) } );
+};/*case end*/
+case 3: {
 {
-JaktInternal::Tuple<DeprecatedString,types::Value> const jakt__name__value__ = name__value__;
-DeprecatedString const name = ((jakt__name__value__).template get<0>());
-types::Value const value = ((jakt__name__value__).template get<1>());
-
-TRY((((((rscope)->comptime_bindings)).set(name,value))));
-}
-
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
+};/*case end*/
+case 4: {
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-
-return (TRY((((*this).perform_final_interpretation_pass(TRY((((*this).typecheck_block(block,runtime_scope)))),runtime_scope,scope)))));
+};/*case end*/
+case 2: {
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> interpreter::Interpreter::perform_final_interpretation_pass(NonnullRefPtr<typename types::CheckedStatement> const statement,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+{
+NonnullRefPtr<typename types::Type> const result_type = ((((*this).program))->get_type(((function_to_run)->return_type_id)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = *result_type;
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedStatement>, ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
-auto&& __jakt_match_variant = *statement;
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+types::FunctionId const constructor = function_to_run_id;
+NonnullRefPtr<typename types::ValueImpl> const impl = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = ((struct_).record_type);
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Expression>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),span))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>(arguments,struct_id,constructor))));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.statement;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Defer>(TRY((((*this).perform_final_interpretation_pass(statement,scope)))),span))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Class>(arguments,struct_id,constructor))));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& vars = __jakt_match_value.vars;
-NonnullRefPtr<typename types::CheckedStatement> const& var_decl = __jakt_match_value.var_decl;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::DestructuringAssignment>(vars,TRY((((*this).perform_final_interpretation_pass(var_decl,scope)))),span))));
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot create instance of non-struct type {}"sv),((struct_).name)))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();types::VarId const& var_id = __jakt_match_value.var_id;
-NonnullRefPtr<typename types::CheckedExpression> const& init = __jakt_match_value.init;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::VarDecl>(var_id,TRY((((*this).perform_final_interpretation_expr_pass(init,scope)))),span))));
+}/*switch end*/
+}()
+));
+return ( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(types::Value(impl,call_span)) } );
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& then_block = __jakt_match_value.then_block;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedStatement>> __jakt_var_197; {
-NonnullRefPtr<typename types::CheckedExpression> const new_condition = TRY((((*this).perform_final_interpretation_expr_pass(condition,scope))));
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> then_statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((then_block).statements)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+types::FunctionId const constructor = function_to_run_id;
+NonnullRefPtr<typename types::ValueImpl> const impl = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = ((struct_).record_type);
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>(arguments,struct_id,constructor))));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Class>(arguments,struct_id,constructor))));
+};/*case end*/
+default: {
 {
-TRY((((then_statements).push(TRY((((*this).perform_final_interpretation_pass(statement,scope))))))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot create instance of non-struct type {}"sv),((struct_).name)))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-
+};/*case end*/
+}/*switch end*/
+}()
+));
+return ( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(types::Value(impl,call_span)) } );
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Implicit constructor can only return a struct or a generic instance"sv)))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-
-types::CheckedBlock const new_then_block = types::CheckedBlock(then_statements,((then_block).scope_id),((then_block).control_flow),((then_block).yielded_type),((then_block).yielded_none));
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const new_else_statement = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>>,ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
-auto __jakt_enum_value = (((else_statement).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>>>(TRY((((*this).perform_final_interpretation_pass((else_statement.value()),scope))))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
-else {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+{
+NonnullRefPtr<typename types::Type> const result_type = ((((*this).program))->get_type(((function_to_run)->return_type_id)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::ExecutionResult>>{
+auto&& __jakt_match_variant = *result_type;
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+{
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+types::FunctionId const constructor = function_to_run_id;
+NonnullRefPtr<typename types::ValueImpl> const impl = TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>(arguments,enum_id,constructor)));
+return ( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(types::Value(impl,call_span)) } );
 }
-}()))
-;
-__jakt_var_197 = TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::If>(new_condition,new_then_block,new_else_statement,span))); goto __jakt_label_185;
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+{
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+types::FunctionId const constructor = function_to_run_id;
+NonnullRefPtr<typename types::ValueImpl> const impl = TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>(arguments,enum_id,constructor)));
+return ( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(types::Value(impl,call_span)) } );
 }
-__jakt_label_185:; __jakt_var_197.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedStatement>> __jakt_var_198; {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+default: {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Implicit enum constructor can only return an enum or a generic instance of one"sv)))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-TRY((((statements).push(TRY((((*this).perform_final_interpretation_pass(statement,scope))))))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Function type {} is not implemented"sv),((function_to_run)->type)))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 }
 
-types::CheckedBlock const new_block = types::CheckedBlock(statements,((block).scope_id),((block).control_flow),((block).yielded_type),((block).yielded_none));
-__jakt_var_198 = TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Block>(new_block,span))); goto __jakt_label_186;
-
-}
-__jakt_label_186:; __jakt_var_198.release_value(); }));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedStatement>> __jakt_var_199; {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+ErrorOr<types::Value> interpreter::Interpreter::tuple_value(JaktInternal::DynamicArray<types::Value> const members,types::TypeId const type,utility::Span const span) {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktTuple>(members,type))),span));
 }
-NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
-{
-TRY((((statements).push(TRY((((*this).perform_final_interpretation_pass(statement,scope))))))));
 }
 
+ErrorOr<NonnullRefPtr<interpreter::Interpreter>> interpreter::Interpreter::create(NonnullRefPtr<compiler::Compiler> const compiler,NonnullRefPtr<types::CheckedProgram> const program,NonnullRefPtr<types::TypecheckFunctions> const typecheck_functions,JaktInternal::DynamicArray<utility::Span> const spans) {
+{
+return (TRY((interpreter::Interpreter::__jakt_create(compiler,program,spans,(TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),(TRY((Set<DeprecatedString>::create_with_values({})))),JaktInternal::OptionalNone(),typecheck_functions))));
 }
 }
 
-types::CheckedBlock const new_block = types::CheckedBlock(statements,((block).scope_id),((block).control_flow),((block).yielded_type),((block).yielded_none));
-__jakt_var_199 = TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Loop>(new_block,span))); goto __jakt_label_187;
-
-}
-__jakt_label_187:; __jakt_var_199.release_value(); }));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedStatement>> __jakt_var_200; {
-NonnullRefPtr<typename types::CheckedExpression> const new_condition = TRY((((*this).perform_final_interpretation_expr_pass(condition,scope))));
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+void interpreter::Interpreter::leave_span() {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::Optional<utility::Span> const dummy = ((((*this).spans)).pop());
 }
-NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
-{
-TRY((((statements).push(TRY((((*this).perform_final_interpretation_pass(statement,scope))))))));
 }
 
+ErrorOr<void> interpreter::Interpreter::enter_span(utility::Span const span) {
+{
+TRY((((((*this).spans)).push(span))));
 }
+return {};
 }
 
-types::CheckedBlock const new_block = types::CheckedBlock(statements,((block).scope_id),((block).control_flow),((block).yielded_type),((block).yielded_none));
-__jakt_var_200 = TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::While>(new_condition,new_block,span))); goto __jakt_label_188;
-
+ErrorOr<types::TypeId> interpreter::Interpreter::tuple_type(JaktInternal::DynamicArray<types::TypeId> const members) {
+{
+types::StructId const tuple_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
+NonnullRefPtr<typename types::Type> const type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(tuple_struct_id,members)));
+return (TRY((((*this).find_or_add_type_id(type)))));
 }
-__jakt_label_188:; __jakt_var_200.release_value(); }));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& val = __jakt_match_value.val;
-JaktInternal::Optional<utility::Span> const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedStatement>,ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
-auto __jakt_enum_value = (((val).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Return>(TRY((((*this).perform_final_interpretation_expr_pass((val.value()),scope)))),span))));
 }
-else {
-return JaktInternal::ExplicitValue(statement);
+
+ErrorOr<bool> interpreter::Interpreter::get_prelude_function(types::ScopeId const scope_id) const {
+{
+types::ScopeId current_scope_id = scope_id;
+types::ScopeId const prelude_scope_id = ((((*this).program))->prelude_scope_id());
+for (;;){
+if (((current_scope_id).equals(prelude_scope_id))){
+return (true);
+}
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(current_scope_id))));
+if (((((scope)->parent)).has_value())){
+(current_scope_id = (((scope)->parent).value()));
+continue;
+}
+return (false);
 }
-}()))
-);
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(statement);
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(statement);
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(statement);
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(statement);
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Throw>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),span))));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Yield>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),span))));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
 }
 }
 
-ErrorOr<JaktInternal::DynamicArray<types::Value>> interpreter::Interpreter::reflect_sum_enum_variants(types::CheckedEnum const subject_enum,utility::Span const span,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
+ErrorOr<types::TypeId> interpreter::Interpreter::find_or_add_type_id(NonnullRefPtr<typename types::Type> const type) {
 {
-types::EnumId const sum_enum_variant_enum_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
-auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("SumEnumVariant"sv)))));
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(id);
-};/*case end*/
-default: {
 {
-utility::panic(Jakt::DeprecatedString("Expected SumEnumVariant to be an enum"sv));
+JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> _magic = ((((((*this).program))->modules)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<types::Module>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-types::FunctionId const typed_variant_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(sum_enum_variant_enum_id))).scope_id),Jakt::DeprecatedString("Typed"sv))))).value());
-types::FunctionId const struct_like_variant_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(sum_enum_variant_enum_id))).scope_id),Jakt::DeprecatedString("StructLike"sv))))).value());
-types::FunctionId const untyped_variant_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(sum_enum_variant_enum_id))).scope_id),Jakt::DeprecatedString("Untyped"sv))))).value());
-types::StructId const field_struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::StructId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
-auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Field"sv)))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(id);
-};/*case end*/
-default: {
+NonnullRefPtr<types::Module> module = (_magic_value.value());
 {
-utility::panic(Jakt::DeprecatedString("Expected Field to be a struct"sv));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<types::Value> result = (TRY((DynamicArray<types::Value>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((subject_enum).variants)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((module)->types)).size()))});
 for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
-types::TypeId const& type_id = __jakt_match_value.type_id;
+size_t id = (_magic_value.value());
 {
-types::Value const type_value = TRY((((*this).reflect_type(type_id,span,scope))));
-types::Value const variant_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>((TRY((DynamicArray<types::Value>::create_with({TRY((((*this).string_value(name,span)))), type_value})))),sum_enum_variant_enum_id,typed_variant_constructor))),span);
-TRY((((result).push(variant_value))));
+if (((((((module)->types))[id]))->equals(type))){
+return (types::TypeId(((module)->id),id));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
-{
-types::Value const variant_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>((TRY((DynamicArray<types::Value>::create_with({TRY((((*this).string_value(name,span))))})))),sum_enum_variant_enum_id,untyped_variant_constructor))),span);
-TRY((((result).push(variant_value))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
-{
-JaktInternal::DynamicArray<types::Value> const reflected_fields = TRY((((*this).reflect_fields(fields,span,scope))));
-types::Value const variant_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>((TRY((DynamicArray<types::Value>::create_with({TRY((((*this).string_value(name,span)))), TRY((((*this).array_value_of_type(reflected_fields,TRY((((*this).array_type_of_struct(field_struct_id)))),span))))})))),sum_enum_variant_enum_id,struct_like_variant_constructor))),span);
-TRY((((result).push(variant_value))));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+
 }
 
 }
 }
 
-return (result);
+TRY((((((((((((*this).program))->modules))[static_cast<i64>(0LL)]))->types)).push(type))));
+return (types::TypeId(types::ModuleId(static_cast<size_t>(0ULL)),(JaktInternal::checked_sub<size_t>(((((((((((*this).program))->modules))[static_cast<i64>(0LL)]))->types)).size()),static_cast<size_t>(1ULL)))));
 }
 }
 
-ErrorOr<types::Value> interpreter::Interpreter::array_value_of_type(JaktInternal::DynamicArray<types::Value> const values,types::TypeId const type,utility::Span const span) {
+ErrorOr<types::CheckedBlock> interpreter::Interpreter::perform_final_interpretation_pass(types::CheckedBlock const block,JaktInternal::Optional<types::ScopeId> const runtime_scope,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
 {
-types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-NonnullRefPtr<typename types::Type> const array_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({type})))))));
-types::TypeId const array_type_id = TRY((((*this).find_or_add_type_id(array_type))));
-return (types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(values,array_type_id))),span));
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+{
+NonnullRefPtr<typename types::CheckedStatement> const new_statement = TRY((((*this).perform_final_interpretation_pass(statement,scope))));
+TRY((((statements).push(new_statement))));
+}
+
 }
 }
 
-ErrorOr<void> interpreter::Interpreter::error_with_hint(DeprecatedString const message,utility::Span const span,DeprecatedString const hint_message,utility::Span const hint_span) {
-{
-TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::MessageWithHint(message,span,hint_message,hint_span) } ))));
-TRY((((((*this).compiler))->print_errors())));
+return (types::CheckedBlock(statements,((block).scope_id),((block).control_flow),((block).yielded_type),((block).yielded_none)));
 }
-return {};
 }
 
-ErrorOr<interpreter::StatementResult> interpreter::Interpreter::call_prelude_function(DeprecatedString const prelude_function,JaktInternal::DynamicArray<types::ResolvedNamespace> const namespace_,JaktInternal::Optional<types::Value> const this_argument,JaktInternal::DynamicArray<types::Value> const arguments,utility::Span const call_span,JaktInternal::Dictionary<DeprecatedString,types::TypeId> const type_bindings) {
+ErrorOr<types::CheckedBlock> interpreter::Interpreter::perform_final_interpretation_pass(parser::ParsedBlock const block,types::ScopeId const runtime_scope,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
 {
-if ((((namespace_).size()) != static_cast<size_t>(1ULL))){
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_201; {
-DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
-};/*case end*/
-default: {
+NonnullRefPtr<types::Scope> rscope = TRY((((((*this).program))->get_scope(runtime_scope))));
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected string as first argument to format, got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+JaktInternal::DictionaryIterator<DeprecatedString,types::Value> _magic = ((TRY((((scope)->all_bindings())))).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::Value>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-__jakt_var_201 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)))))),call_span)) } ; goto __jakt_label_189;
+JaktInternal::Tuple<DeprecatedString,types::Value> name__value__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::Value> const jakt__name__value__ = name__value__;
+DeprecatedString const name = ((jakt__name__value__).template get<0>());
+types::Value const value = ((jakt__name__value__).template get<1>());
 
+TRY((((((rscope)->comptime_bindings)).set(name,value))));
 }
-__jakt_label_189:; __jakt_var_201.release_value(); }));
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_202; {
-DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+}
+
+return (TRY((((*this).perform_final_interpretation_pass(TRY((((*this).typecheck_block(block,runtime_scope)))),runtime_scope,scope)))));
+}
+}
+
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> interpreter::Interpreter::perform_final_interpretation_pass(NonnullRefPtr<typename types::CheckedStatement> const statement,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedStatement>, ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
+auto&& __jakt_match_variant = *statement;
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Expression>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),span))));
 };/*case end*/
-default: {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.statement;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Defer>(TRY((((*this).perform_final_interpretation_pass(statement,scope)))),span))));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& vars = __jakt_match_value.vars;
+NonnullRefPtr<typename types::CheckedStatement> const& var_decl = __jakt_match_value.var_decl;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::DestructuringAssignment>(vars,TRY((((*this).perform_final_interpretation_pass(var_decl,scope)))),span))));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();types::VarId const& var_id = __jakt_match_value.var_id;
+NonnullRefPtr<typename types::CheckedExpression> const& init = __jakt_match_value.init;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::VarDecl>(var_id,TRY((((*this).perform_final_interpretation_expr_pass(init,scope)))),span))));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& then_block = __jakt_match_value.then_block;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedStatement>> __jakt_var_197; {
+NonnullRefPtr<typename types::CheckedExpression> const new_condition = TRY((((*this).perform_final_interpretation_expr_pass(condition,scope))));
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> then_statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("println expects a string as its first argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((then_block).statements)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+{
+TRY((((then_statements).push(TRY((((*this).perform_final_interpretation_pass(statement,scope))))))));
+}
+
+}
+}
+
+types::CheckedBlock const new_then_block = types::CheckedBlock(then_statements,((then_block).scope_id),((then_block).control_flow),((then_block).yielded_type),((then_block).yielded_none));
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const new_else_statement = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>>,ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
+auto __jakt_enum_value = (((else_statement).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>>>(TRY((((*this).perform_final_interpretation_pass((else_statement.value()),scope))))));
+}
+else {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+}
+}()))
+;
+__jakt_var_197 = TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::If>(new_condition,new_then_block,new_else_statement,span))); goto __jakt_label_183;
+
 }
+__jakt_label_183:; __jakt_var_197.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-));
-DeprecatedString const formatted_string = TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return (outln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedStatement>> __jakt_var_198; {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return (warnln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+{
+TRY((((statements).push(TRY((((*this).perform_final_interpretation_pass(statement,scope))))))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return (out(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+
 }
-else {
-return (warn(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
 }
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-__jakt_var_202 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_190;
+
+types::CheckedBlock const new_block = types::CheckedBlock(statements,((block).scope_id),((block).control_flow),((block).yielded_type),((block).yielded_none));
+__jakt_var_198 = TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Block>(new_block,span))); goto __jakt_label_184;
 
 }
-__jakt_label_190:; __jakt_var_202.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_203; {
-DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+__jakt_label_184:; __jakt_var_198.release_value(); }));
 };/*case end*/
-default: {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedStatement>> __jakt_var_199; {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("println expects a string as its first argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-DeprecatedString const formatted_string = TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return (outln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return (warnln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+{
+TRY((((statements).push(TRY((((*this).perform_final_interpretation_pass(statement,scope))))))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return (out(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+
 }
-else {
-return (warn(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
 }
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-__jakt_var_203 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_191;
+
+types::CheckedBlock const new_block = types::CheckedBlock(statements,((block).scope_id),((block).control_flow),((block).yielded_type),((block).yielded_none));
+__jakt_var_199 = TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Loop>(new_block,span))); goto __jakt_label_185;
 
 }
-__jakt_label_191:; __jakt_var_203.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_204; {
-DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+__jakt_label_185:; __jakt_var_199.release_value(); }));
 };/*case end*/
-default: {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedStatement>> __jakt_var_200; {
+NonnullRefPtr<typename types::CheckedExpression> const new_condition = TRY((((*this).perform_final_interpretation_expr_pass(condition,scope))));
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("println expects a string as its first argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((((block).statements)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-DeprecatedString const formatted_string = TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return (outln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+NonnullRefPtr<typename types::CheckedStatement> statement = (_magic_value.value());
+{
+TRY((((statements).push(TRY((((*this).perform_final_interpretation_pass(statement,scope))))))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return (warnln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return (out(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+
+types::CheckedBlock const new_block = types::CheckedBlock(statements,((block).scope_id),((block).control_flow),((block).yielded_type),((block).yielded_none));
+__jakt_var_200 = TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::While>(new_condition,new_block,span))); goto __jakt_label_186;
+
+}
+__jakt_label_186:; __jakt_var_200.release_value(); }));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& val = __jakt_match_value.val;
+JaktInternal::Optional<utility::Span> const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedStatement>,ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
+auto __jakt_enum_value = (((val).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Return>(TRY((((*this).perform_final_interpretation_expr_pass((val.value()),scope)))),span))));
 }
 else {
-return (warn(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(statement);
 }
-return JaktInternal::ExplicitValue<void>();
 }()))
-;
-__jakt_var_204 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_192;
-
+);
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(statement);
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(statement);
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(statement);
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(statement);
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Throw>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),span))));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Yield>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),span))));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-__jakt_label_192:; __jakt_var_204.release_value(); }));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_205; {
-DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+
+ErrorOr<types::Value> interpreter::Interpreter::reflect_methods(utility::Span const span) {
+{
+types::StructId const method_struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::StructId, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Method"sv)))));
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(id);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("println expects a string as its first argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Expected Method to be a struct"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 ));
-DeprecatedString const formatted_string = TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-return (outln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-return (warnln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
-return (out(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
-}
-else {
-return (warn(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-__jakt_var_205 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_193;
-
+types::FunctionId const method_struct_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_struct(method_struct_id))).scope_id),Jakt::DeprecatedString("Method"sv))))).value());
+JaktInternal::DynamicArray<types::Value> method_values = (TRY((DynamicArray<types::Value>::create_with({}))));
+return (types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(method_values,TRY((((*this).array_type_of_struct(method_struct_id))))))),span));
 }
-__jakt_label_193:; __jakt_var_205.release_value(); }));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("as_saturated"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_206; {
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function((((TRY((((((*this).program))->find_functions_with_name_in_scope(((((*this).program))->prelude_scope_id()),Jakt::DeprecatedString("as_saturated"sv))))).value()))[static_cast<i64>(0LL)])));
-JaktInternal::Optional<types::TypeId> const output_type_id = ((type_bindings).get(TRY((((((((((((function)->generics))->params))[static_cast<i64>(0LL)])).type_id())).to_string())))));
-__jakt_var_206 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((interpreter::cast_value_to_type(((arguments)[static_cast<i64>(0LL)]),(output_type_id.value()),*this,true)))) } ; goto __jakt_label_194;
 
-}
-__jakt_label_194:; __jakt_var_206.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("unchecked_mul"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_207; {
-types::Value const lhs_value = ((arguments)[static_cast<i64>(0LL)]);
-types::Value const rhs_value = ((arguments)[static_cast<i64>(1LL)]);
-utility::Span const span = call_span;
-__jakt_var_207 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+ErrorOr<interpreter::StatementResult> interpreter::Interpreter::execute_binary_operator(types::Value const lhs_value,types::Value const rhs_value,parser::BinaryOperator const op,utility::Span const span,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 2: {
@@ -3709,7 +3543,7 @@ switch(__jakt_match_variant.index()) {
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
 u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(unchecked_mul<u8>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_add<u8>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3730,7 +3564,7 @@ switch(__jakt_match_variant.index()) {
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
 u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>(unchecked_mul<u16>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_add<u16>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3751,7 +3585,7 @@ switch(__jakt_match_variant.index()) {
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
 u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(unchecked_mul<u32>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_add<u32>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3772,7 +3606,7 @@ switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
 u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(unchecked_mul<u64>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3793,7 +3627,7 @@ switch(__jakt_match_variant.index()) {
 case 6: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
 i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>(unchecked_mul<i8>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_add<i8>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3814,7 +3648,7 @@ switch(__jakt_match_variant.index()) {
 case 7: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
 i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>(unchecked_mul<i16>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_add<i16>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3835,7 +3669,7 @@ switch(__jakt_match_variant.index()) {
 case 8: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
 i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(unchecked_mul<i32>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_add<i32>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3856,7 +3690,7 @@ switch(__jakt_match_variant.index()) {
 case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
 i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>(unchecked_mul<i64>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_add<i64>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3877,7 +3711,7 @@ switch(__jakt_match_variant.index()) {
 case 10: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
 f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>(unchecked_mul<f32>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>((x + y)))));
 };/*case end*/
 default: {
 {
@@ -3898,7 +3732,7 @@ switch(__jakt_match_variant.index()) {
 case 11: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
 f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>(unchecked_mul<f64>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>((x + y)))));
 };/*case end*/
 default: {
 {
@@ -3919,7 +3753,7 @@ switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
 size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(unchecked_mul<size_t>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3931,6 +3765,17 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>((x + y)))));
+};/*case end*/
 default: {
 {
 TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
@@ -3939,17 +3784,20 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } ; goto __jakt_label_195;
-
-}
-__jakt_label_195:; __jakt_var_207.release_value(); }));
+)));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("unchecked_add"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_208; {
-types::Value const lhs_value = ((arguments)[static_cast<i64>(0LL)]);
-types::Value const rhs_value = ((arguments)[static_cast<i64>(1LL)]);
-utility::Span const span = call_span;
-__jakt_var_208 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+};/*case end*/
+}/*switch end*/
+}()
+)),span)) } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 2: {
@@ -3961,7 +3809,7 @@ switch(__jakt_match_variant.index()) {
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
 u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(unchecked_add<u8>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_sub<u8>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -3982,7 +3830,7 @@ switch(__jakt_match_variant.index()) {
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
 u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>(unchecked_add<u16>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_sub<u16>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -4003,7 +3851,7 @@ switch(__jakt_match_variant.index()) {
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
 u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(unchecked_add<u32>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_sub<u32>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -4024,7 +3872,7 @@ switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
 u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(unchecked_add<u64>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_sub<u64>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -4045,7 +3893,7 @@ switch(__jakt_match_variant.index()) {
 case 6: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
 i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>(unchecked_add<i8>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_sub<i8>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -4066,7 +3914,7 @@ switch(__jakt_match_variant.index()) {
 case 7: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
 i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>(unchecked_add<i16>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_sub<i16>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -4087,7 +3935,7 @@ switch(__jakt_match_variant.index()) {
 case 8: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
 i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(unchecked_add<i32>(x,y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_sub<i32>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -4108,80 +3956,7 @@ switch(__jakt_match_variant.index()) {
 case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
 i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>(unchecked_add<i64>(x,y)))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>(unchecked_add<f32>(x,y)))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>(unchecked_add<f64>(x,y)))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(unchecked_add<size_t>(x,y)))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_sub<i64>(x,y))))));
 };/*case end*/
 default: {
 {
@@ -4191,1094 +3966,863 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } ; goto __jakt_label_196;
-
-}
-__jakt_label_196:; __jakt_var_208.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("___jakt_get_target_triple_string"sv)) {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((((*this).compiler))->target_triple).try_value_or_lazy_evaluated([&]() -> ErrorOr<DeprecatedString> { return TRY((___jakt_get_target_triple_string())); })))))),call_span)) } );
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("abort"sv)) {
-{
-abort();
-}
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("Set"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_209; {
-if ((((type_bindings).size()) != static_cast<size_t>(1ULL))){
-TRY((((*this).error(Jakt::DeprecatedString("Set constructor expects one generic argument"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-types::StructId const set_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Set"sv)))));
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(set_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({(((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(0LL)]))).value())})))))))))));
-__jakt_var_209 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktSet>((TRY((DynamicArray<types::Value>::create_with({})))),type_id))),call_span)) } ; goto __jakt_label_197;
-
-}
-__jakt_label_197:; __jakt_var_209.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("Dictionary"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_210; {
-if ((((type_bindings).size()) != static_cast<size_t>(2ULL))){
-TRY((((*this).error(Jakt::DeprecatedString("Dictionary constructor expects two generic argumenst"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-types::StructId const dictionary_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(dictionary_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({(((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(0LL)]))).value()), (((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(1LL)]))).value())})))))))))));
-__jakt_var_210 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktDictionary>((TRY((DynamicArray<types::Value>::create_with({})))),(TRY((DynamicArray<types::Value>::create_with({})))),type_id))),call_span)) } ; goto __jakt_label_198;
-
-}
-__jakt_label_198:; __jakt_var_210.release_value(); }));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function {}::{} is not implemented yet"sv),namespace_,prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((((namespace_)[static_cast<i64>(0LL)])).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("Error"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("from_errno"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_211; {
-types::Value const err = ((arguments)[static_cast<i64>(0LL)]);
-types::StructId const error_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
-types::CheckedStruct const error_struct = ((((*this).program))->get_struct(error_struct_id));
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((error_struct).scope_id)))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructors = ((((scope)->functions)).get(Jakt::DeprecatedString("from_errno"sv)));
-__jakt_var_211 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({err})))),error_struct_id,(((constructors.value()))[static_cast<i64>(0LL)])))),call_span)) } ; goto __jakt_label_199;
-
-}
-__jakt_label_199:; __jakt_var_211.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("from_string_literal"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_212; {
-types::Value const err = ((arguments)[static_cast<i64>(0LL)]);
-types::StructId const error_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
-types::CheckedStruct const error_struct = ((((*this).program))->get_struct(error_struct_id));
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((error_struct).scope_id)))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructors = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
-__jakt_var_212 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({err})))),error_struct_id,(((constructors.value()))[static_cast<i64>(0LL)])))),call_span)) } ; goto __jakt_label_200;
-
-}
-__jakt_label_200:; __jakt_var_212.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("code"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& code = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(code))),call_span)) } );
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Error should have `i32` as its code, but got {}"sv),((((fields)[static_cast<i64>(0LL)])).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Error::code` expects an Error as its this argument, but got {}"sv),(((this_argument.value())).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Error::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("File"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("open_for_reading"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_213; {
-DeprecatedString const requested_path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` expects a string as its first argument, but got {}"sv),prelude_function,((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-jakt__path::Path const path = TRY((((TRY(((((TRY((((((((*this).program))->compiler))->get_file_path(((call_span).file_id))))).value())).parent())))).join(requested_path))));
-types::Value const path_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(((path).to_string())))),call_span);
-if ((!(((path).exists())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` could not find file at path {}"sv),prelude_function,((path).to_string())))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
-types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructors = ((((scope)->functions)).get(Jakt::DeprecatedString("open_for_reading"sv)));
-__jakt_var_213 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({path_value})))),file_struct_id,(((constructors.value()))[static_cast<i64>(0LL)])))),call_span)) } ; goto __jakt_label_201;
-
-}
-__jakt_label_201:; __jakt_var_213.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("open_for_writing"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_214; {
-DeprecatedString const requested_path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` expects a string as its first argument, but got {}"sv),prelude_function,((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-jakt__path::Path const path = TRY((((TRY(((((TRY((((((((*this).program))->compiler))->get_file_path(((call_span).file_id))))).value())).parent())))).join(requested_path))));
-types::Value const path_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(((path).to_string())))),call_span);
-if ((!(((path).exists())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` could not find file at path {}"sv),prelude_function,((path).to_string())))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
-types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructor = ((((scope)->functions)).get(Jakt::DeprecatedString("open_for_writing"sv)));
-__jakt_var_214 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({path_value})))),file_struct_id,(((constructor.value()))[static_cast<i64>(0LL)])))),call_span)) } ; goto __jakt_label_202;
-
-}
-__jakt_label_202:; __jakt_var_214.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("read_all"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_215; {
-DeprecatedString const path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>((x - y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("invalid type for File::read_all"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>((x - y)))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::read_all` expects a `File` as its this argument, but got {}"sv),(((this_argument.value())).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
-types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
-types::FunctionId const open_for_reading = (((((((scope)->functions)).get(Jakt::DeprecatedString("open_for_reading"sv))).value()))[static_cast<i64>(0LL)]);
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::Optional<types::FunctionId> const& constructor = __jakt_match_value.constructor;
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_sub<size_t>(x,y))))));
+};/*case end*/
+default: {
 {
-if (((!(((constructor).has_value()))) || (!((((constructor.value())).equals(open_for_reading)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot read from a file not opened for reading"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-}
-return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+)));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("expected struct as this argument"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-));
-NonnullRefPtr<File> file = TRY((File::open_for_reading(path)));
-JaktInternal::DynamicArray<types::Value> result_values = (TRY((DynamicArray<types::Value>::create_with({}))));
-{
-JaktInternal::ArrayIterator<u8> _magic = ((TRY((((file)->read_all())))).iterator());
-for (;;){
-JaktInternal::Optional<u8> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-u8 byte = (_magic_value.value());
-{
-TRY((((result_values).push(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(byte))),call_span)))));
-}
-
-}
-}
-
-types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-__jakt_var_215 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(result_values,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )})))))))))))))),call_span)) } ; goto __jakt_label_203;
-
-}
-__jakt_label_203:; __jakt_var_215.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("read"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_216; {
-DeprecatedString const path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)),span)) } );
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_mul<u8>(x,y))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("invalid type for File::read"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_mul<u16>(x,y))))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::read` expects a `File` as its this argument, but got {}"sv),(((this_argument.value())).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
-types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
-types::FunctionId const open_for_reading = (((((((scope)->functions)).get(Jakt::DeprecatedString("open_for_reading"sv))).value()))[static_cast<i64>(0LL)]);
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::Optional<types::FunctionId> const& constructor = __jakt_match_value.constructor;
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_mul<u32>(x,y))))));
+};/*case end*/
+default: {
 {
-if (((!(((constructor).has_value()))) || (!((((constructor.value())).equals(open_for_reading)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot read from a file not opened for reading"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-}
-return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_mul<u64>(x,y))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("expected struct as this argument"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-));
-NonnullRefPtr<File> file = TRY((File::open_for_reading(path)));
-JaktInternal::DynamicArray<types::Value> values_buffer = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::Value>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(values);
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_mul<i8>(x,y))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::read` expects a `[u8]` as its argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-JaktInternal::DynamicArray<u8> byte_buffer = (TRY((DynamicArray<u8>::filled(((values_buffer).size()), static_cast<u8>(0)))));
-size_t const bytes_read = TRY((((file)->read(byte_buffer))));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((byte_buffer).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-(((values_buffer)[i]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((byte_buffer)[i])))),call_span));
-}
-
-}
-}
-
-__jakt_var_216 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(bytes_read))),call_span)) } ; goto __jakt_label_204;
-
-}
-__jakt_label_204:; __jakt_var_216.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("exists"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_217; {
-DeprecatedString const requested_path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_mul<i16>(x,y))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` expects a string as its first argument, but got {}"sv),prelude_function,((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-jakt__path::Path const path = TRY((((TRY(((((TRY((((((((*this).program))->compiler))->get_file_path(((call_span).file_id))))).value())).parent())))).join(requested_path))));
-__jakt_var_217 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((path).exists())))),call_span)) } ; goto __jakt_label_205;
-
-}
-__jakt_label_205:; __jakt_var_217.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("write"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_218; {
-DeprecatedString const path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_mul<i32>(x,y))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("invalid type for File::write"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_mul<i64>(x,y))))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::write` expects a `File` as its this argument, but got {}"sv),(((this_argument.value())).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
-types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
-types::FunctionId const open_for_writing = (((((((scope)->functions)).get(Jakt::DeprecatedString("open_for_writing"sv))).value()))[static_cast<i64>(0LL)]);
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::Optional<types::FunctionId> const& constructor = __jakt_match_value.constructor;
-{
-if (((!(((constructor).has_value()))) || (!((((constructor.value())).equals(open_for_writing)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot write to a file not opened for writing"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-}
-return JaktInternal::ExplicitValue<void>();
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>((x * y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("expected struct as this argument"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-));
-NonnullRefPtr<File> file = TRY((File::open_for_writing(path)));
-JaktInternal::DynamicArray<types::Value> data_values = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::Value>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(values);
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>((x * y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::write` expects a `[u8]` as its argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-JaktInternal::DynamicArray<u8> data = (TRY((DynamicArray<u8>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::Value> _magic = ((data_values).iterator());
-for (;;){
-JaktInternal::Optional<types::Value> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::Value val = (_magic_value.value());
-{
-TRY((((data).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((val).impl);
+)));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_mul<size_t>(x,y))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("expected byte"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))));
-}
-
-}
-}
-
-size_t const bytes_written = TRY((((file)->write(data))));
-__jakt_var_218 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(bytes_written))),call_span)) } ; goto __jakt_label_206;
-
-}
-__jakt_label_206:; __jakt_var_218.release_value(); }));
-}
-else {
+)));
+};/*case end*/
+default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("StringBuilder"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("create"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_219; {
-types::StructId const string_builder_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("StringBuilder"sv)))));
-__jakt_var_219 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(Jakt::DeprecatedString(""sv)))),call_span)})))),string_builder_struct_id,JaktInternal::OptionalNone()))),call_span)) } ; goto __jakt_label_207;
-
-}
-__jakt_label_207:; __jakt_var_219.release_value(); }));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_220; {
-JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString> fields_current_string_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+}/*switch end*/
+}()
+)),span)) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((Tuple{fields, value}));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_div<u8>(x,y))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_div<u16>(x,y))))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-JaktInternal::DynamicArray<types::Value> fields = ((fields_current_string_).template get<0>());
-DeprecatedString current_string = ((fields_current_string_).template get<1>());
-
-DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
-TRY((((builder).append_string(current_string))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
-return (TRY((((builder).append(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_div<u32>(x,y))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid use of StringBuilder::append({})"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
-return (TRY((((builder).append_string(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_div<u64>(x,y))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_string()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
-return (TRY((((builder).append_escaped_for_json(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_div<i8>(x,y))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_escaped_for_json()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
-return (TRY((((builder).append_code_point(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u32, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_div<i16>(x,y))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_code_point()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-abort();
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((builder).to_string())))))),call_span));
-__jakt_var_220 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_208;
-
-}
-__jakt_label_208:; __jakt_var_220.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_221; {
-JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString> fields_current_string_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((Tuple{fields, value}));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_div<i32>(x,y))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_div<i64>(x,y))))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-JaktInternal::DynamicArray<types::Value> fields = ((fields_current_string_).template get<0>());
-DeprecatedString current_string = ((fields_current_string_).template get<1>());
-
-DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
-TRY((((builder).append_string(current_string))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
-return (TRY((((builder).append(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>((x / y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid use of StringBuilder::append({})"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
-return (TRY((((builder).append_string(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>((x / y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_string()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
-return (TRY((((builder).append_escaped_for_json(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_div<size_t>(x,y))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_escaped_for_json()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
-return (TRY((((builder).append_code_point(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u32, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+)));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_code_point()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-abort();
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((builder).to_string())))))),call_span));
-__jakt_var_221 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_209;
-
-}
-__jakt_label_209:; __jakt_var_221.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_222; {
-JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString> fields_current_string_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)),span)) } );
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((Tuple{fields, value}));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<types::Value> fields = ((fields_current_string_).template get<0>());
-DeprecatedString current_string = ((fields_current_string_).template get<1>());
-
-DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
-TRY((((builder).append_string(current_string))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
-return (TRY((((builder).append(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid use of StringBuilder::append({})"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
-return (TRY((((builder).append_string(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_string()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
-return (TRY((((builder).append_escaped_for_json(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_escaped_for_json()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
-return (TRY((((builder).append_code_point(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u32, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_code_point()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-abort();
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((builder).to_string())))))),call_span));
-__jakt_var_222 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_210;
-
-}
-__jakt_label_210:; __jakt_var_222.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_223; {
-JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString> fields_current_string_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((Tuple{fields, value}));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-JaktInternal::DynamicArray<types::Value> fields = ((fields_current_string_).template get<0>());
-DeprecatedString current_string = ((fields_current_string_).template get<1>());
-
-DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
-TRY((((builder).append_string(current_string))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
-return (TRY((((builder).append(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid use of StringBuilder::append({})"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
-return (TRY((((builder).append_string(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_string()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
-return (TRY((((builder).append_escaped_for_json(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_escaped_for_json()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
-return (TRY((((builder).append_code_point(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u32, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_code_point()"sv),call_span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))))), JaktInternal::ExplicitValue<void>();
-}
-else {
+)));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
+int const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
+int const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+};/*case end*/
+default: {
 {
-abort();
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((builder).to_string())))))),call_span));
-__jakt_var_223 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_211;
-
-}
-__jakt_label_211:; __jakt_var_223.release_value(); }));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("to_string"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[static_cast<i64>(0LL)])) } );
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 13: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).is_empty())))),call_span)) } );
+DeprecatedString const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
@@ -5287,365 +4831,242 @@ utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv))
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("length"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)),span)) } );
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((value).length())))),call_span)) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("clear"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_224; {
-JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
-(((((mutable_fields)[static_cast<i64>(0LL)])).impl) = TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(Jakt::DeprecatedString(""sv)))));
-__jakt_var_224 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_212;
-
-}
-__jakt_label_212:; __jakt_var_224.release_value(); }));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("Dictionary"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("Dictionary"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_225; {
-if ((((type_bindings).size()) != static_cast<size_t>(2ULL))){
-TRY((((*this).error(Jakt::DeprecatedString("Dictionary constructor expects two generic argumenst"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-types::StructId const dictionary_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(dictionary_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({(((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(0LL)]))).value()), (((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(1LL)]))).value())})))))))))));
-__jakt_var_225 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktDictionary>((TRY((DynamicArray<types::Value>::create_with({})))),(TRY((DynamicArray<types::Value>::create_with({})))),type_id))),call_span)) } ; goto __jakt_label_213;
-
-}
-__jakt_label_213:; __jakt_var_225.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("get"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_226; {
-JaktInternal::Optional<size_t> found_index = JaktInternal::OptionalNone();
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if (((((((keys)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
-(found_index = i);
-break;
-}
-}
-
-}
-}
-
-__jakt_var_226 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((found_index).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(((values)[(found_index.value())])))),call_span));
-}
-else {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span));
-}
-}()))
-) } ; goto __jakt_label_214;
-
-}
-__jakt_label_214:; __jakt_var_226.release_value(); }));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::get()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("set"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_227; {
-JaktInternal::Optional<size_t> found_index = JaktInternal::OptionalNone();
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+};/*case end*/
+default: {
 {
-if (((((((keys)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
-(found_index = i);
-break;
-}
-}
-
-}
-}
-
-JaktInternal::DynamicArray<types::Value> mutable_keys = keys;
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-if (((found_index).has_value())){
-(((mutable_values)[(found_index.value())]) = ((arguments)[static_cast<i64>(1LL)]));
-}
-else {
-TRY((((mutable_keys).push(((arguments)[static_cast<i64>(0LL)])))));
-TRY((((mutable_values).push(((arguments)[static_cast<i64>(1LL)])))));
-}
-
-__jakt_var_227 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_215;
-
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_215:; __jakt_var_227.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::set()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((((keys).is_empty()) && ((values).is_empty()))))),call_span)) } );
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::is_empty()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("contains"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_228; {
-bool found = false;
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if (((((((keys)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
-(found = true);
-break;
-}
-}
-
-}
-}
-
-__jakt_var_228 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(found))),call_span)) } ; goto __jakt_label_216;
-
-}
-__jakt_label_216:; __jakt_var_228.release_value(); }));
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::contains()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("remove"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_229; {
-JaktInternal::Optional<size_t> found_index = JaktInternal::OptionalNone();
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if (((((((keys)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
-(found_index = i);
-break;
-}
-}
-
-}
-}
-
-if (((found_index).has_value())){
-JaktInternal::DynamicArray<types::Value> keys_without = (TRY((DynamicArray<types::Value>::create_with({}))));
-JaktInternal::DynamicArray<types::Value> values_without = (TRY((DynamicArray<types::Value>::create_with({}))));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if ((i == (found_index.value()))){
-continue;
-}
-TRY((((keys_without).push(((keys)[i])))));
-TRY((((values_without).push(((values)[i])))));
-}
-
-}
-}
-
-JaktInternal::DynamicArray<types::Value> mutable_keys = keys;
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-((mutable_keys).shrink(static_cast<size_t>(0ULL)));
-((mutable_values).shrink(static_cast<size_t>(0ULL)));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys_without).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+};/*case end*/
+default: {
 {
-TRY((((mutable_keys).push(((keys_without)[i])))));
-TRY((((mutable_values).push(((values_without)[i])))));
-}
-
-}
-}
-
-}
-__jakt_var_229 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((found_index).has_value())))),call_span)) } ; goto __jakt_label_217;
-
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_217:; __jakt_var_229.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::remove()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("ensure_capacity"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& capacity = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_230; {
-JaktInternal::DynamicArray<types::Value> mutable_keys = keys;
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-TRY((((mutable_keys).ensure_capacity(capacity))));
-TRY((((mutable_values).ensure_capacity(capacity))));
-__jakt_var_230 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_218;
-
-}
-__jakt_label_218:; __jakt_var_230.release_value(); }));
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Dictionary::ensure_capacity must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -5653,476 +5074,447 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
+int const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
+int const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::ensure_capacity()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("capacity"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((keys).capacity())))),call_span)) } );
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::capacity()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("clear"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)),span)) } );
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_231; {
-JaktInternal::DynamicArray<types::Value> mutable_keys = keys;
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-((mutable_keys).shrink(static_cast<size_t>(0ULL)));
-((mutable_values).shrink(static_cast<size_t>(0ULL)));
-__jakt_var_231 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_219;
-
-}
-__jakt_label_219:; __jakt_var_231.release_value(); }));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::clear()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("size"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((keys).size())))),call_span)) } );
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::size()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("keys"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_232; {
-JaktInternal::DynamicArray<types::TypeId> const generics = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(args);
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("expected generic instance"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-__jakt_var_232 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = ((((generics).size()) == static_cast<size_t>(2ULL)));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_233; {
-types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({((generics)[static_cast<i64>(0LL)])})))))))))));
-__jakt_var_233 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(keys,type_id))),call_span)) } ; goto __jakt_label_221;
-
-}
-__jakt_label_221:; __jakt_var_233.release_value(); }));
-}
-else {
-{
-utility::panic(Jakt::DeprecatedString("dictionary should have 2 generic args. one for keys, one for values"sv));
-}
-}
-}()))
-; goto __jakt_label_220;
-
-}
-__jakt_label_220:; __jakt_var_232.release_value(); }));
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::keys()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("iterator"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 21: {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_234; {
-types::StructId const struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("DictionaryIterator"sv)))));
-__jakt_var_234 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({(this_argument.value()), types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(static_cast<size_t>(0ULL)))),call_span)})))),struct_id,JaktInternal::OptionalNone()))),call_span)) } ; goto __jakt_label_222;
-
-}
-__jakt_label_222:; __jakt_var_234.release_value(); }));
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::iterator()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Dictionary::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("Array"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("iterator"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_235; {
-types::StructId const struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("ArrayIterator"sv)))));
-__jakt_var_235 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({(this_argument.value()), types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(static_cast<size_t>(0ULL)))),call_span)})))),struct_id,JaktInternal::OptionalNone()))),call_span)) } ; goto __jakt_label_223;
-
-}
-__jakt_label_223:; __jakt_var_235.release_value(); }));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::iterator()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("size"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_236; {
-__jakt_var_236 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((values).size())))),call_span)) } ; goto __jakt_label_224;
-
-}
-__jakt_label_224:; __jakt_var_236.release_value(); }));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::size()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("push"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_237; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-TRY((((mutable_values).push(((arguments)[static_cast<i64>(0LL)])))));
-__jakt_var_237 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_225;
-
-}
-__jakt_label_225:; __jakt_var_237.release_value(); }));
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::push()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("push_values"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_238; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-{
-{
-JaktInternal::ArrayIterator<types::Value> _magic = ((values).iterator());
-for (;;){
-JaktInternal::Optional<types::Value> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::Value value = (_magic_value.value());
-{
-TRY((((mutable_values).push(value))));
-}
-
-}
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
-return (TRY((((*this).error(Jakt::DeprecatedString("Only argument to push_values needs to be another Array"sv),call_span))))), JaktInternal::ExplicitValue<void>();
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
 };/*case end*/
 }/*switch end*/
 }()
-));
-__jakt_var_238 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_226;
-
-}
-__jakt_label_226:; __jakt_var_238.release_value(); }));
+)));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::push_values()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("pop"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_239; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-JaktInternal::Optional<types::Value> const value = ((mutable_values).pop());
-__jakt_var_239 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((value).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue((value.value())) } );
-}
-else {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span)) } );
-}
-}()))
-; goto __jakt_label_227;
-
-}
-__jakt_label_227:; __jakt_var_239.release_value(); }));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::push()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("first"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_240; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-JaktInternal::Optional<types::Value> const value = ((mutable_values).first());
-__jakt_var_240 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((value).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue((value.value())) } );
-}
-else {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span)) } );
-}
-}()))
-; goto __jakt_label_228;
-
-}
-__jakt_label_228:; __jakt_var_240.release_value(); }));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::push()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("last"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+}/*switch end*/
+}()
+)),span)) } );
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_241; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-JaktInternal::Optional<types::Value> const value = ((mutable_values).last());
-__jakt_var_241 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((value).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue((value.value())) } );
-}
-else {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span)) } );
-}
-}()))
-; goto __jakt_label_229;
-
-}
-__jakt_label_229:; __jakt_var_241.release_value(); }));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::push()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("contains"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_242; {
-bool found = false;
-{
-JaktInternal::ArrayIterator<types::Value> _magic = ((values).iterator());
-for (;;){
-JaktInternal::Optional<types::Value> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::Value value = (_magic_value.value());
-{
-if (((((value).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
-(found = true);
-break;
-}
-}
-
-}
-}
-
-__jakt_var_242 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(found))),call_span)) } ; goto __jakt_label_230;
-
-}
-__jakt_label_230:; __jakt_var_242.release_value(); }));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::contains()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((values).is_empty())))),call_span)) } );
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::is_empty()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("capacity"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_243; {
-__jakt_var_243 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((values).capacity())))),call_span)) } ; goto __jakt_label_231;
-
-}
-__jakt_label_231:; __jakt_var_243.release_value(); }));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::capacity()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("ensure_capacity"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& capacity = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_244; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-TRY((((mutable_values).ensure_capacity(capacity))));
-__jakt_var_244 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_232;
-
-}
-__jakt_label_232:; __jakt_var_244.release_value(); }));
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Array::ensure_capacity must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -6130,38 +5522,41 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::ensure_capacity()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("add_capacity"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& capacity = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_245; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-TRY((((mutable_values).add_capacity(capacity))));
-__jakt_var_245 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_233;
-
-}
-__jakt_label_233:; __jakt_var_245.release_value(); }));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Array::add_capacity must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -6169,38 +5564,41 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::add_capacity()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("shrink"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& size = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_246; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-((mutable_values).shrink(size));
-__jakt_var_246 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_234;
-
-}
-__jakt_label_234:; __jakt_var_246.release_value(); }));
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Array::shrink must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -6208,481 +5606,468 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Array::shrink()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Array::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("ArrayIterator"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("next"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_247; {
-size_t const index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid ArrayIterator index configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
-__jakt_var_247 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = ((((values).size()) > index));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_248; {
-(((mutable_fields)[static_cast<i64>(1LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(index,static_cast<size_t>(1ULL)))))),call_span));
-__jakt_var_248 = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(((values)[index])))),call_span); goto __jakt_label_236;
-
-}
-__jakt_label_236:; __jakt_var_248.release_value(); }));
-}
-else {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span));
-}
-}()))
-);
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid ArrayIterator configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))) } ; goto __jakt_label_235;
-
-}
-__jakt_label_235:; __jakt_var_247.release_value(); }));
+)));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid ArrayIterator configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `ArrayIterator::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("Range"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("next"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_249; {
-JaktInternal::DynamicArray<types::Value> fields = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::Value>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)),span)) } );
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(fields);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Range::next()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-u64 const start = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+)));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+}/*switch end*/
+}()
+)));
 };/*case end*/
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
 u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
 };/*case end*/
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
 u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid type for comptime range"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-u64 const end = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
-switch(__jakt_match_variant.index()) {
+)));
+};/*case end*/
 case 6: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
 i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
 };/*case end*/
 case 7: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
 i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
 };/*case end*/
 case 8: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
 i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
 };/*case end*/
 case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
 i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid type for comptime range"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-if ((start == end)){
-return ( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span)) } );
-}
-if ((start > end)){
-(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_sub<u64>(start,static_cast<u64>(1ULL)))))),call_span));
-}
-else {
-(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(start,static_cast<u64>(1ULL)))))),call_span));
-}
-
-__jakt_var_249 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(start))),call_span)))),call_span)) } ; goto __jakt_label_237;
-
-}
-__jakt_label_237:; __jakt_var_249.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("inclusive"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::StructId const& struct_id = __jakt_match_value.struct_id;
-JaktInternal::Optional<types::FunctionId> const& constructor = __jakt_match_value.constructor;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_250; {
-JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
-u64 const end = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+)));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+}/*switch end*/
+}()
+)));
 };/*case end*/
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
 size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid type for comptime range"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-(((((mutable_fields)[static_cast<i64>(1LL)])).impl) = TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(end,static_cast<u64>(1ULL)))))));
-__jakt_var_250 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>(fields,struct_id,constructor))),(((this_argument.value())).span))) } ; goto __jakt_label_238;
-
-}
-__jakt_label_238:; __jakt_var_250.release_value(); }));
+)));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Range::inclusive()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("exclusive"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)),span)) } );
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 17: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue((this_argument.value())) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Range::exclusive()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Range::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("String"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).is_empty())))),call_span)) } );
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("length"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((value).length())))),call_span)) } );
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("hash"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(((value).hash())))),call_span)) } );
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("substring"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& start = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_251; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_251 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_239;
-
-}
-__jakt_label_239:; __jakt_var_251.release_value(); }));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_252; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_252 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_240;
-
-}
-__jakt_label_240:; __jakt_var_252.release_value(); }));
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_253; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_253 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_241;
-
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_241:; __jakt_var_253.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_254; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_254 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_242;
-
-}
-__jakt_label_242:; __jakt_var_254.release_value(); }));
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_255; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_255 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_243;
-
-}
-__jakt_label_243:; __jakt_var_255.release_value(); }));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -6690,65 +6075,41 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& start = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_256; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_256 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_244;
-
-}
-__jakt_label_244:; __jakt_var_256.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_257; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_257 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_245;
-
-}
-__jakt_label_245:; __jakt_var_257.release_value(); }));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_258; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_258 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_246;
-
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_246:; __jakt_var_258.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_259; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_259 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_247;
-
-}
-__jakt_label_247:; __jakt_var_259.release_value(); }));
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_260; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_260 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_248;
-
-}
-__jakt_label_248:; __jakt_var_260.release_value(); }));
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -6756,65 +6117,20 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& start = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_261; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_261 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_249;
-
-}
-__jakt_label_249:; __jakt_var_261.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_262; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_262 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_250;
-
-}
-__jakt_label_250:; __jakt_var_262.release_value(); }));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_263; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_263 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_251;
-
-}
-__jakt_label_251:; __jakt_var_263.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_264; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_264 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_252;
-
-}
-__jakt_label_252:; __jakt_var_264.release_value(); }));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_265; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_265 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_253;
-
-}
-__jakt_label_253:; __jakt_var_265.release_value(); }));
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
+f32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -6822,65 +6138,20 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& start = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_266; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_266 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_254;
-
-}
-__jakt_label_254:; __jakt_var_266.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_267; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_267 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_255;
-
-}
-__jakt_label_255:; __jakt_var_267.release_value(); }));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_268; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_268 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_256;
-
-}
-__jakt_label_256:; __jakt_var_268.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_269; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_269 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_257;
-
-}
-__jakt_label_257:; __jakt_var_269.release_value(); }));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_270; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_270 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_258;
-
-}
-__jakt_label_258:; __jakt_var_270.release_value(); }));
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
+f64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -6888,65 +6159,41 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& start = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_271; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_271 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_259;
-
-}
-__jakt_label_259:; __jakt_var_271.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_272; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_272 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_260;
-
-}
-__jakt_label_260:; __jakt_var_272.release_value(); }));
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_273; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_273 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_261;
-
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_261:; __jakt_var_273.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_274; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_274 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_262;
-
-}
-__jakt_label_262:; __jakt_var_274.release_value(); }));
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& length = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_275; {
-DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
-__jakt_var_275 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_263;
-
-}
-__jakt_label_263:; __jakt_var_275.release_value(); }));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -6956,184 +6203,200 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
+)),span)) } );
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x & y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("number"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& number = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& number = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& number = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
 };/*case end*/
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& number = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x & y))))))));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& number = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& number = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& number = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x & y)))));
 };/*case end*/
-case 12: {
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::number must not be called with a usize or u64"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
 case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x & y)))));
+};/*case end*/
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::number must not be called with a usize or u64"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x & y))))))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::number must be called with an integer"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("to_uint"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_276; {
-JaktInternal::Optional<u32> const result = ((value).to_uint());
-__jakt_var_276 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((result).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((result.value())))),call_span)))));
-}
-else {
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())));
-}
-}()))
-,call_span)) } ; goto __jakt_label_264;
-
-}
-__jakt_label_264:; __jakt_var_276.release_value(); }));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x & y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("to_int"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_277; {
-JaktInternal::Optional<i32> const result = ((value).to_int());
-__jakt_var_277 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((result).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((result.value())))),call_span)))));
-}
-else {
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())));
-}
-}()))
-,call_span)) } ; goto __jakt_label_265;
-
-}
-__jakt_label_265:; __jakt_var_277.release_value(); }));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x & y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("is_whitespace"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).is_whitespace())))),call_span)) } );
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x & y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("contains"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& arg = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).contains(arg))))),call_span)) } );
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x & y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::contains must be called with a string"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7143,37 +6406,32 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("replace"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
+)),span)) } );
+};/*case end*/
 case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& replace = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& with = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(((value).replace(replace,with))))),call_span)) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x | y))))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::replace must be called with strings"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7181,9 +6439,20 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x | y))))))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::replace must be called with strings"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7191,53 +6460,41 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x | y)))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("byte_at"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& index = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
 };/*case end*/
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& index = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& index = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& index = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& index = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x | y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::byte_at must be called with an unsigned integer"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7245,55 +6502,41 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x | y))))))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("split"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& c = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_278; {
-JaktInternal::DynamicArray<DeprecatedString> const values = ((value).split(c));
-JaktInternal::DynamicArray<types::Value> result = (TRY((DynamicArray<types::Value>::create_with({}))));
-{
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((values).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-DeprecatedString value = (_magic_value.value());
-{
-TRY((((result).push(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(value))),call_span)))));
-}
-
-}
-}
-
-types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-__jakt_var_278 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(result,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } )})))))))))))))),call_span)) } ; goto __jakt_label_266;
-
-}
-__jakt_label_266:; __jakt_var_278.release_value(); }));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x | y))))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::split must be called with a c_char"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7301,33 +6544,41 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x | y)))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("starts_with"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& arg = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).starts_with(arg))))),call_span)) } );
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x | y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::starts_with must be called with a string"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7335,33 +6586,55 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x | y)))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("ends_with"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+}/*switch end*/
+}()
+)),span)) } );
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& arg = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).ends_with(arg))))),call_span)) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x ^ y))))))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::ends_with must be called with a string"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7369,38 +6642,41 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x ^ y))))))));
+};/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid String"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("repeated"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_279; {
-if ((((arguments).size()) != static_cast<size_t>(2ULL))){
-TRY((((*this).error(Jakt::DeprecatedString("String::repeated must be called with a c_char and a usize"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-JaktInternal::Tuple<char,size_t> const character_count_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<char,size_t>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& arg = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<char,size_t>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& c = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((Tuple{arg, c}));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x ^ y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::repeated must be called with a usize"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7408,267 +6684,223 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x ^ y)))));
+};/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("String::repeated must be called with a c_char"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-char const character = ((character_count_).template get<0>());
-size_t const count = ((character_count_).template get<1>());
-
-__jakt_var_279 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::repeated(character,count)))),call_span)) } ; goto __jakt_label_267;
-
-}
-__jakt_label_267:; __jakt_var_279.release_value(); }));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `String::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("Set"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("Set"sv)) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_280; {
-if ((((type_bindings).size()) != static_cast<size_t>(1ULL))){
-TRY((((*this).error(Jakt::DeprecatedString("Set constructor expects one generic argument"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-types::StructId const set_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Set"sv)))));
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(set_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({(((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(0LL)]))).value())})))))))))));
-__jakt_var_280 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktSet>((TRY((DynamicArray<types::Value>::create_with({})))),type_id))),call_span)) } ; goto __jakt_label_268;
-
-}
-__jakt_label_268:; __jakt_var_280.release_value(); }));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+)));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((values).is_empty())))),call_span)) } );
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x ^ y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("contains"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_281; {
-bool found = false;
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((values).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if (((((((values)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
-(found = true);
-break;
-}
-}
-
-}
-}
-
-__jakt_var_281 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(found))),call_span)) } ; goto __jakt_label_269;
-
-}
-__jakt_label_269:; __jakt_var_281.release_value(); }));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x ^ y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("add"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_282; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-TRY((((mutable_values).push(((arguments)[static_cast<i64>(0LL)])))));
-__jakt_var_282 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_270;
-
-}
-__jakt_label_270:; __jakt_var_282.release_value(); }));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x ^ y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("remove"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_283; {
-bool found = false;
-JaktInternal::DynamicArray<types::Value> values_without = (TRY((DynamicArray<types::Value>::create_with({}))));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((values).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if (((((((values)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
-(found = true);
-continue;
-}
-TRY((((values_without).push(((values)[i])))));
-}
-
-}
-}
-
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-((mutable_values).shrink(static_cast<size_t>(0ULL)));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((values_without).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x ^ y)))));
+};/*case end*/
+default: {
 {
-TRY((((mutable_values).push(((values_without)[i])))));
-}
-
-}
-}
-
-__jakt_var_283 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(found))),call_span)) } ; goto __jakt_label_271;
-
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_271:; __jakt_var_283.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x ^ y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("clear"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+}/*switch end*/
+}()
+)),span)) } );
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_284; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-((mutable_values).shrink(static_cast<size_t>(0ULL)));
-__jakt_var_284 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_272;
-
-}
-__jakt_label_272:; __jakt_var_284.release_value(); }));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x << y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("size"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((values).size())))),call_span)) } );
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x << y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("capacity"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((values).capacity())))),call_span)) } );
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x << y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("ensure_capacity"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& capacity = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_285; {
-JaktInternal::DynamicArray<types::Value> mutable_values = values;
-TRY((((mutable_values).ensure_capacity(capacity))));
-__jakt_var_285 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_273;
-
-}
-__jakt_label_273:; __jakt_var_285.release_value(); }));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x << y)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Set::ensure_capacity must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -7676,481 +6908,325 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-default: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("iterator"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_286; {
-types::StructId const struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("SetIterator"sv)))));
-__jakt_var_286 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({(this_argument.value()), types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(static_cast<size_t>(0ULL)))),call_span)})))),struct_id,JaktInternal::OptionalNone()))),call_span)) } ; goto __jakt_label_274;
-
-}
-__jakt_label_274:; __jakt_var_286.release_value(); }));
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x << y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid use of Set::iterator()"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Set::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("SetIterator"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("next"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_287; {
-size_t const index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x << y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid SetIterator index configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
-__jakt_var_287 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+)));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = ((((values).size()) > index));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_288; {
-(((mutable_fields)[static_cast<i64>(1LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(index,static_cast<size_t>(1ULL)))))),call_span));
-__jakt_var_288 = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(((values)[index])))),call_span); goto __jakt_label_276;
-
-}
-__jakt_label_276:; __jakt_var_288.release_value(); }));
-}
-else {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span));
-}
-}()))
-);
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x << y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid SetIterator configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))) } ; goto __jakt_label_275;
-
-}
-__jakt_label_275:; __jakt_var_287.release_value(); }));
+)));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x << y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid SetIterator configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `ArrayIterator::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("DictionaryIterator"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("next"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_289; {
-size_t const index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x << y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid DictionaryIterator index configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
-__jakt_var_289 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
-switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
-JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((((keys).size()) > index) && (((values).size()) > index)));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_290; {
-(((mutable_fields)[static_cast<i64>(1LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(index,static_cast<size_t>(1ULL)))))),call_span));
-JaktInternal::DynamicArray<types::TypeId> const generics = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(args);
+)));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("expected generic instance"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-types::StructId const tuple_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
-types::TypeId const tuple_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(tuple_struct_id,generics)))))));
-__jakt_var_290 = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktTuple>((TRY((DynamicArray<types::Value>::create_with({((keys)[index]), ((values)[index])})))),tuple_type_id))),call_span)))),call_span); goto __jakt_label_278;
-
-}
-__jakt_label_278:; __jakt_var_290.release_value(); }));
-}
-else {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span));
-}
-}()))
-);
+)),span)) } );
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x >> y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid DictionaryIterator configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))) } ; goto __jakt_label_277;
-
-}
-__jakt_label_277:; __jakt_var_289.release_value(); }));
+)));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x >> y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid DictionaryIterator configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `DictionaryIterator::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("Optional"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (prelude_function);
-if (__jakt_enum_value == Jakt::DeprecatedString("has_value"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 24: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(true))),call_span)) } );
 };/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(false))),call_span)) } );
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x >> y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Optional configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("value"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
 };/*case end*/
-case 25: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot unwrap optional none"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::UnwrapOptionalNone))));
-}
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x >> y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Optional configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("value_or"sv)) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
 };/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((arguments)[static_cast<i64>(0LL)])) } );
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x >> y))))))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid Optional configuration"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Optional::{}` is not implemented"sv),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-else {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `{}::{}` is not implemented"sv),((((namespace_)[static_cast<i64>(0LL)])).name),prelude_function))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-}
-}()))
-);
-}
-}
-
-ErrorOr<void> interpreter::Interpreter::enter_span(utility::Span const span) {
-{
-TRY((((((*this).spans)).push(span))));
-}
-return {};
-}
-
-ErrorOr<bool> interpreter::Interpreter::get_prelude_function(types::ScopeId const scope_id) const {
-{
-types::ScopeId current_scope_id = scope_id;
-types::ScopeId const prelude_scope_id = ((((*this).program))->prelude_scope_id());
-for (;;){
-if (((current_scope_id).equals(prelude_scope_id))){
-return (true);
-}
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(current_scope_id))));
-if (((((scope)->parent)).has_value())){
-(current_scope_id = (((scope)->parent).value()));
-continue;
-}
-return (false);
-}
-}
-}
-
-ErrorOr<interpreter::StatementResult> interpreter::Interpreter::execute_expression(NonnullRefPtr<typename types::CheckedExpression> const expr,NonnullRefPtr<interpreter::InterpreterScope> scope) {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((((*this).current_function_id)).has_value()));
-if (__jakt_enum_value == false) {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_expression_without_cast(expr,scope)))));
-}
-else {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression_without_cast(expr,scope))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Return(TRY((interpreter::cast_value_to_type(value,((((((*this).program))->get_function((((*this).current_function_id).value()))))->return_type_id),*this,false)))) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((interpreter::cast_value_to_type(value,((expr)->type()),*this,false)))) } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Yield(value) } );
 };/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x >> y))))))));
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
-}
-}()))
-);
-}
-}
-
-ErrorOr<types::Value> interpreter::Interpreter::tuple_value(JaktInternal::DynamicArray<types::Value> const members,types::TypeId const type,utility::Span const span) {
-{
-return (types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktTuple>(members,type))),span));
-}
-}
-
-ErrorOr<JaktInternal::DynamicArray<types::Value>> interpreter::Interpreter::reflect_fields(JaktInternal::DynamicArray<types::VarId> const fields,utility::Span const span,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
-{
-types::StructId const field_struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::StructId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
-auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Field"sv)))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(id);
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x >> y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Expected Field to be a struct"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-types::FunctionId const field_struct_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_struct(field_struct_id))).scope_id),Jakt::DeprecatedString("Field"sv))))).value());
-types::EnumId const visibility_enum_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
-auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Visibility"sv)))));
+)));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(id);
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x >> y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Expected Visibility to be an enum"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-types::FunctionId const visibility_public_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(visibility_enum_id))).scope_id),Jakt::DeprecatedString("Public"sv))))).value());
-types::FunctionId const visibility_private_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(visibility_enum_id))).scope_id),Jakt::DeprecatedString("Private"sv))))).value());
-types::StructId const variable_declaration_struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::StructId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
-auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("VariableDeclaration"sv)))));
+)));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(id);
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x >> y)))));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Expected VariableDeclaration to be a struct"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-types::FunctionId const variable_declaration_struct_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_struct(variable_declaration_struct_id))).scope_id),Jakt::DeprecatedString("VariableDeclaration"sv))))).value());
-JaktInternal::DynamicArray<types::Value> record_type_fields = (TRY((DynamicArray<types::Value>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
-for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::VarId var_id = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const field = ((((*this).program))->get_variable(var_id));
-types::Value const variable = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(((field)->name)))),span), TRY((((*this).reflect_type(((field)->type_id),span,scope)))), types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((field)->is_mutable)))),span)})))),variable_declaration_struct_id,variable_declaration_struct_constructor))),span);
-types::Value const field_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({variable, types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>((TRY((DynamicArray<types::Value>::create_with({})))),visibility_enum_id,JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::FunctionId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
-auto&& __jakt_match_variant = ((field)->visibility);
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(visibility_public_constructor);
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(visibility_private_constructor);
+)));
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Not implemented"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))))),span)})))),field_struct_id,field_struct_constructor))),span);
-TRY((((record_type_fields).push(field_value))));
-}
-
-}
-}
-
-return (record_type_fields);
-}
-}
-
-ErrorOr<interpreter::StatementResult> interpreter::Interpreter::execute_binary_operator(types::Value const lhs_value,types::Value const rhs_value,parser::BinaryOperator const op,utility::Span const span,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 0: {
+)),span)) } );
+};/*case end*/
+case 16: {
 return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
@@ -8163,7 +7239,7 @@ switch(__jakt_match_variant.index()) {
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
 u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_add<u8>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x << y))))))));
 };/*case end*/
 default: {
 {
@@ -8184,7 +7260,7 @@ switch(__jakt_match_variant.index()) {
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
 u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_add<u16>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x << y))))))));
 };/*case end*/
 default: {
 {
@@ -8205,7 +7281,7 @@ switch(__jakt_match_variant.index()) {
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
 u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_add<u32>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x << y)))));
 };/*case end*/
 default: {
 {
@@ -8226,7 +7302,7 @@ switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
 u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x << y)))));
 };/*case end*/
 default: {
 {
@@ -8247,7 +7323,7 @@ switch(__jakt_match_variant.index()) {
 case 6: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
 i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_add<i8>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x << y))))))));
 };/*case end*/
 default: {
 {
@@ -8268,7 +7344,7 @@ switch(__jakt_match_variant.index()) {
 case 7: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
 i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_add<i16>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x << y))))))));
 };/*case end*/
 default: {
 {
@@ -8289,7 +7365,7 @@ switch(__jakt_match_variant.index()) {
 case 8: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
 i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_add<i32>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x << y)))));
 };/*case end*/
 default: {
 {
@@ -8310,7 +7386,7 @@ switch(__jakt_match_variant.index()) {
 case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
 i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_add<i64>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x << y)))));
 };/*case end*/
 default: {
 {
@@ -8322,16 +7398,16 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>((x + y)))));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x << y)))));
 };/*case end*/
 default: {
 {
@@ -8343,16 +7419,30 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)),span)) } );
+};/*case end*/
+case 17: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>((x + y)))));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(JaktInternal::arithmetic_shift_right(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8364,16 +7454,16 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(x,y))))));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>(JaktInternal::arithmetic_shift_right(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8385,16 +7475,16 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>((x + y)))));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(JaktInternal::arithmetic_shift_right(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8406,6 +7496,17 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(JaktInternal::arithmetic_shift_right(x,y)))));
+};/*case end*/
 default: {
 {
 TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
@@ -8414,22 +7515,39 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
+)));
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>(JaktInternal::arithmetic_shift_right(x,y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_sub<u8>(x,y))))));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>(JaktInternal::arithmetic_shift_right(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8441,16 +7559,16 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_sub<u16>(x,y))))));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(JaktInternal::arithmetic_shift_right(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8462,16 +7580,16 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_sub<u32>(x,y))))));
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>(JaktInternal::arithmetic_shift_right(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8483,16 +7601,16 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_sub<u64>(x,y))))));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(JaktInternal::arithmetic_shift_right(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8504,16 +7622,65 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)),span)) } );
+};/*case end*/
+case 19: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
+bool const& x = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((rhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_sub<i8>(x,y))))));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
+bool const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x || y)))));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)),span)) } );
+};/*case end*/
+case 18: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
+bool const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((rhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
+bool const& y = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x && y)))));
 };/*case end*/
 default: {
 {
@@ -8525,17 +7692,6 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_sub<i16>(x,y))))));
-};/*case end*/
 default: {
 {
 TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
@@ -8544,125 +7700,290 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 }/*switch end*/
 }()
-)));
+)),span)) } );
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_sub<i32>(x,y))))));
+case 21: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(rhs_value) } );
+};/*case end*/
+case 22: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseAnd() } ,span,scope)))));
+};/*case end*/
+case 23: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseOr() } ,span,scope)))));
+};/*case end*/
+case 24: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseXor() } ,span,scope)))));
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseLeftShift() } ,span,scope)))));
+};/*case end*/
+case 26: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseRightShift() } ,span,scope)))));
+};/*case end*/
+case 27: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Add() } ,span,scope)))));
+};/*case end*/
+case 28: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Subtract() } ,span,scope)))));
+};/*case end*/
+case 29: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Multiply() } ,span,scope)))));
+};/*case end*/
+case 30: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Modulo() } ,span,scope)))));
+};/*case end*/
+case 31: {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Divide() } ,span,scope)))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unimplemented binary operator '{}'"sv),op))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+}
+
+ErrorOr<types::Value> interpreter::Interpreter::array_value_of_type(JaktInternal::DynamicArray<types::Value> const values,types::TypeId const type,utility::Span const span) {
+{
+types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+NonnullRefPtr<typename types::Type> const array_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({type})))))));
+types::TypeId const array_type_id = TRY((((*this).find_or_add_type_id(array_type))));
+return (types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(values,array_type_id))),span));
+}
+}
+
+ErrorOr<void> interpreter::Interpreter::error_with_hint(DeprecatedString const message,utility::Span const span,DeprecatedString const hint_message,utility::Span const hint_span) {
+{
+TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::MessageWithHint(message,span,hint_message,hint_span) } ))));
+TRY((((((*this).compiler))->print_errors())));
+}
+return {};
+}
+
+ErrorOr<types::TypeId> interpreter::Interpreter::array_type_of_struct(types::StructId const struct_id) {
+{
+types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+NonnullRefPtr<typename types::Type> const type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({((((((*this).program))->get_struct(struct_id))).type_id)})))))));
+return (TRY((((*this).find_or_add_type_id(type)))));
+}
+}
+
+ErrorOr<interpreter::StatementResult> interpreter::Interpreter::call_prelude_function(DeprecatedString const prelude_function,JaktInternal::DynamicArray<types::ResolvedNamespace> const namespace_,JaktInternal::Optional<types::Value> const this_argument,JaktInternal::DynamicArray<types::Value> const arguments,utility::Span const call_span,JaktInternal::Dictionary<DeprecatedString,types::TypeId> const type_bindings) {
+{
+if ((((namespace_).size()) != static_cast<size_t>(1ULL))){
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_201; {
+DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_sub<i64>(x,y))))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected string as first argument to format, got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+__jakt_var_201 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)))))),call_span)) } ; goto __jakt_label_187;
+
+}
+__jakt_label_187:; __jakt_var_201.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_202; {
+DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>((x - y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("println expects a string as its first argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+DeprecatedString const formatted_string = TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return (outln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return (warnln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return (out(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else {
+return (warn(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+__jakt_var_202 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_188;
+
+}
+__jakt_label_188:; __jakt_var_202.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_203; {
+DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>((x - y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("println expects a string as its first argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+DeprecatedString const formatted_string = TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return (outln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return (warnln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return (out(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else {
+return (warn(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+__jakt_var_203 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_189;
+
+}
+__jakt_label_189:; __jakt_var_203.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_204; {
+DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_sub<size_t>(x,y))))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("println expects a string as its first argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
+));
+DeprecatedString const formatted_string = TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return (outln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return (warnln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return (out(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else {
+return (warn(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+__jakt_var_204 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_190;
+
+}
+__jakt_label_190:; __jakt_var_204.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_205; {
+DeprecatedString const format_string = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("println expects a string as its first argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+));
+DeprecatedString const formatted_string = TRY((interpreter::comptime_format_impl(format_string,((arguments)[(JaktInternal::Range<i64>{static_cast<i64>(static_cast<i64>(1LL)),static_cast<i64>(9223372036854775807LL)})]),*this)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+return (outln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+return (warnln(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return (out(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+else {
+return (warn(Jakt::DeprecatedString("{}"sv),formatted_string)), JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+__jakt_var_205 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_191;
+
+}
+__jakt_label_191:; __jakt_var_205.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("as_saturated"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_206; {
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function((((TRY((((((*this).program))->find_functions_with_name_in_scope(((((*this).program))->prelude_scope_id()),Jakt::DeprecatedString("as_saturated"sv))))).value()))[static_cast<i64>(0LL)])));
+JaktInternal::Optional<types::TypeId> const output_type_id = ((type_bindings).get(TRY((((((((((((function)->generics))->params))[static_cast<i64>(0LL)])).type_id())).to_string())))));
+__jakt_var_206 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((interpreter::cast_value_to_type(((arguments)[static_cast<i64>(0LL)]),(output_type_id.value()),*this,true)))) } ; goto __jakt_label_192;
+
+}
+__jakt_label_192:; __jakt_var_206.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("unchecked_mul"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_207; {
+types::Value const lhs_value = ((arguments)[static_cast<i64>(0LL)]);
+types::Value const rhs_value = ((arguments)[static_cast<i64>(1LL)]);
+utility::Span const span = call_span;
+__jakt_var_207 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 2: {
@@ -8674,7 +7995,7 @@ switch(__jakt_match_variant.index()) {
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
 u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_mul<u8>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(unchecked_mul<u8>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8695,7 +8016,7 @@ switch(__jakt_match_variant.index()) {
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
 u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_mul<u16>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>(unchecked_mul<u16>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8716,7 +8037,7 @@ switch(__jakt_match_variant.index()) {
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
 u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_mul<u32>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(unchecked_mul<u32>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8737,7 +8058,7 @@ switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
 u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_mul<u64>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(unchecked_mul<u64>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8758,7 +8079,7 @@ switch(__jakt_match_variant.index()) {
 case 6: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
 i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_mul<i8>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>(unchecked_mul<i8>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8779,7 +8100,7 @@ switch(__jakt_match_variant.index()) {
 case 7: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
 i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_mul<i16>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>(unchecked_mul<i16>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8800,7 +8121,7 @@ switch(__jakt_match_variant.index()) {
 case 8: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
 i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_mul<i32>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(unchecked_mul<i32>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8821,7 +8142,7 @@ switch(__jakt_match_variant.index()) {
 case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
 i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_mul<i64>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>(unchecked_mul<i64>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8842,7 +8163,7 @@ switch(__jakt_match_variant.index()) {
 case 10: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
 f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>((x * y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>(unchecked_mul<f32>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8863,7 +8184,7 @@ switch(__jakt_match_variant.index()) {
 case 11: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
 f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>((x * y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>(unchecked_mul<f64>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8884,7 +8205,7 @@ switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
 size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_mul<size_t>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(unchecked_mul<size_t>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8904,10 +8225,17 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
+)),span)) } ; goto __jakt_label_193;
+
+}
+__jakt_label_193:; __jakt_var_207.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("unchecked_add"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_208; {
+types::Value const lhs_value = ((arguments)[static_cast<i64>(0LL)]);
+types::Value const rhs_value = ((arguments)[static_cast<i64>(1LL)]);
+utility::Span const span = call_span;
+__jakt_var_208 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 2: {
@@ -8919,7 +8247,7 @@ switch(__jakt_match_variant.index()) {
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
 u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_div<u8>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(unchecked_add<u8>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8940,7 +8268,7 @@ switch(__jakt_match_variant.index()) {
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
 u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_div<u16>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>(unchecked_add<u16>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8961,7 +8289,7 @@ switch(__jakt_match_variant.index()) {
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
 u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_div<u32>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(unchecked_add<u32>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -8982,7 +8310,7 @@ switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
 u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_div<u64>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(unchecked_add<u64>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -9003,7 +8331,7 @@ switch(__jakt_match_variant.index()) {
 case 6: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
 i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_div<i8>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>(unchecked_add<i8>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -9024,7 +8352,7 @@ switch(__jakt_match_variant.index()) {
 case 7: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
 i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_div<i16>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>(unchecked_add<i16>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -9045,7 +8373,7 @@ switch(__jakt_match_variant.index()) {
 case 8: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
 i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_div<i32>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(unchecked_add<i32>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -9066,7 +8394,7 @@ switch(__jakt_match_variant.index()) {
 case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
 i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_div<i64>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>(unchecked_add<i64>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -9087,7 +8415,7 @@ switch(__jakt_match_variant.index()) {
 case 10: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
 f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>((x / y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>(unchecked_add<f32>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -9108,7 +8436,7 @@ switch(__jakt_match_variant.index()) {
 case 11: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
 f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>((x / y)))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>(unchecked_add<f64>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -9129,7 +8457,7 @@ switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
 size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_div<size_t>(x,y))))));
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(unchecked_add<size_t>(x,y)))));
 };/*case end*/
 default: {
 {
@@ -9149,47 +8477,100 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
-};/*case end*/
-default: {
+)),span)) } ; goto __jakt_label_194;
+
+}
+__jakt_label_194:; __jakt_var_208.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("___jakt_get_target_triple_string"sv)) {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((((*this).compiler))->target_triple).try_value_or_lazy_evaluated([&]() -> ErrorOr<DeprecatedString> { return TRY((___jakt_get_target_triple_string())); })))))),call_span)) } );
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("abort"sv)) {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+abort();
+}
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("Set"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_209; {
+if ((((type_bindings).size()) != static_cast<size_t>(1ULL))){
+TRY((((*this).error(Jakt::DeprecatedString("Set constructor expects one generic argument"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+types::StructId const set_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Set"sv)))));
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(set_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({(((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(0LL)]))).value())})))))))))));
+__jakt_var_209 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktSet>((TRY((DynamicArray<types::Value>::create_with({})))),type_id))),call_span)) } ; goto __jakt_label_195;
+
+}
+__jakt_label_195:; __jakt_var_209.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("Dictionary"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_210; {
+if ((((type_bindings).size()) != static_cast<size_t>(2ULL))){
+TRY((((*this).error(Jakt::DeprecatedString("Dictionary constructor expects two generic argumenst"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+types::StructId const dictionary_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(dictionary_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({(((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(0LL)]))).value()), (((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(1LL)]))).value())})))))))))));
+__jakt_var_210 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktDictionary>((TRY((DynamicArray<types::Value>::create_with({})))),(TRY((DynamicArray<types::Value>::create_with({})))),type_id))),call_span)) } ; goto __jakt_label_196;
+
+}
+__jakt_label_196:; __jakt_var_210.release_value(); }));
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function {}::{} is not implemented yet"sv),namespace_,prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((((namespace_)[static_cast<i64>(0LL)])).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("Error"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("from_errno"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_211; {
+types::Value const err = ((arguments)[static_cast<i64>(0LL)]);
+types::StructId const error_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
+types::CheckedStruct const error_struct = ((((*this).program))->get_struct(error_struct_id));
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((error_struct).scope_id)))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructors = ((((scope)->functions)).get(Jakt::DeprecatedString("from_errno"sv)));
+__jakt_var_211 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({err})))),error_struct_id,(((constructors.value()))[static_cast<i64>(0LL)])))),call_span)) } ; goto __jakt_label_197;
+
+}
+__jakt_label_197:; __jakt_var_211.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("from_string_literal"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_212; {
+types::Value const err = ((arguments)[static_cast<i64>(0LL)]);
+types::StructId const error_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
+types::CheckedStruct const error_struct = ((((*this).program))->get_struct(error_struct_id));
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((error_struct).scope_id)))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructors = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
+__jakt_var_212 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({err})))),error_struct_id,(((constructors.value()))[static_cast<i64>(0LL)])))),call_span)) } ; goto __jakt_label_198;
+
+}
+__jakt_label_198:; __jakt_var_212.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("code"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& code = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(code))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Error should have `i32` as its code, but got {}"sv),((((fields)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -9197,252 +8578,319 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Error::code` expects an Error as its this argument, but got {}"sv),(((this_argument.value())).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Error::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("File"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("open_for_reading"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_213; {
+DeprecatedString const requested_path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` expects a string as its first argument, but got {}"sv),prelude_function,((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+jakt__path::Path const path = TRY((((TRY(((((TRY((((((((*this).program))->compiler))->get_file_path(((call_span).file_id))))).value())).parent())))).join(requested_path))));
+types::Value const path_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(((path).to_string())))),call_span);
+if ((!(((path).exists())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` could not find file at path {}"sv),prelude_function,((path).to_string())))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
+types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructors = ((((scope)->functions)).get(Jakt::DeprecatedString("open_for_reading"sv)));
+__jakt_var_213 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({path_value})))),file_struct_id,(((constructors.value()))[static_cast<i64>(0LL)])))),call_span)) } ; goto __jakt_label_199;
+
+}
+__jakt_label_199:; __jakt_var_213.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("open_for_writing"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_214; {
+DeprecatedString const requested_path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` expects a string as its first argument, but got {}"sv),prelude_function,((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+jakt__path::Path const path = TRY((((TRY(((((TRY((((((((*this).program))->compiler))->get_file_path(((call_span).file_id))))).value())).parent())))).join(requested_path))));
+types::Value const path_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(((path).to_string())))),call_span);
+if ((!(((path).exists())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` could not find file at path {}"sv),prelude_function,((path).to_string())))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
+types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructor = ((((scope)->functions)).get(Jakt::DeprecatedString("open_for_writing"sv)));
+__jakt_var_214 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({path_value})))),file_struct_id,(((constructor.value()))[static_cast<i64>(0LL)])))),call_span)) } ; goto __jakt_label_200;
+
+}
+__jakt_label_200:; __jakt_var_214.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("read_all"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_215; {
+DeprecatedString const path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("invalid type for File::read_all"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::read_all` expects a `File` as its this argument, but got {}"sv),(((this_argument.value())).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
+types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
+types::FunctionId const open_for_reading = (((((((scope)->functions)).get(Jakt::DeprecatedString("open_for_reading"sv))).value()))[static_cast<i64>(0LL)]);
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::Optional<types::FunctionId> const& constructor = __jakt_match_value.constructor;
+{
+if (((!(((constructor).has_value()))) || (!((((constructor.value())).equals(open_for_reading)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot read from a file not opened for reading"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("expected struct as this argument"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+NonnullRefPtr<File> file = TRY((File::open_for_reading(path)));
+JaktInternal::DynamicArray<types::Value> result_values = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::ArrayIterator<u8> _magic = ((TRY((((file)->read_all())))).iterator());
+for (;;){
+JaktInternal::Optional<u8> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+u8 byte = (_magic_value.value());
+{
+TRY((((result_values).push(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(byte))),call_span)))));
+}
+
+}
+}
+
+types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+__jakt_var_215 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(result_values,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )})))))))))))))),call_span)) } ; goto __jakt_label_201;
+
+}
+__jakt_label_201:; __jakt_var_215.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("read"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_216; {
+DeprecatedString const path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("invalid type for File::read"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::read` expects a `File` as its this argument, but got {}"sv),(((this_argument.value())).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
+types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
+types::FunctionId const open_for_reading = (((((((scope)->functions)).get(Jakt::DeprecatedString("open_for_reading"sv))).value()))[static_cast<i64>(0LL)]);
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::Optional<types::FunctionId> const& constructor = __jakt_match_value.constructor;
+{
+if (((!(((constructor).has_value()))) || (!((((constructor.value())).equals(open_for_reading)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot read from a file not opened for reading"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("expected struct as this argument"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
-int const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+NonnullRefPtr<File> file = TRY((File::open_for_reading(path)));
+JaktInternal::DynamicArray<types::Value> values_buffer = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::Value>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
-int const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(values);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::read` expects a `[u8]` as its argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+JaktInternal::DynamicArray<u8> byte_buffer = (TRY((DynamicArray<u8>::filled(((values_buffer).size()), static_cast<u8>(0)))));
+size_t const bytes_read = TRY((((file)->read(byte_buffer))));
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((byte_buffer).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+(((values_buffer)[i]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((byte_buffer)[i])))),call_span));
+}
+
+}
+}
+
+__jakt_var_216 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(bytes_read))),call_span)) } ; goto __jakt_label_202;
+
+}
+__jakt_label_202:; __jakt_var_216.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("exists"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_217; {
+DeprecatedString const requested_path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` expects a string as its first argument, but got {}"sv),prelude_function,((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+jakt__path::Path const path = TRY((((TRY(((((TRY((((((((*this).program))->compiler))->get_file_path(((call_span).file_id))))).value())).parent())))).join(requested_path))));
+__jakt_var_217 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((path).exists())))),call_span)) } ; goto __jakt_label_203;
+
+}
+__jakt_label_203:; __jakt_var_217.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("write"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_218; {
+DeprecatedString const path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
 case 13: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x == y)))));
+DeprecatedString const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("invalid type for File::write"sv));
 }
 };/*case end*/
 }/*switch end*/
@@ -9451,837 +8899,1039 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::write` expects a `File` as its this argument, but got {}"sv),(((this_argument.value())).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+types::StructId const file_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("File"sv)))));
+types::CheckedStruct const file_struct = ((((*this).program))->get_struct(file_struct_id));
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((file_struct).scope_id)))));
+types::FunctionId const open_for_writing = (((((((scope)->functions)).get(Jakt::DeprecatedString("open_for_writing"sv))).value()))[static_cast<i64>(0LL)]);
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::Optional<types::FunctionId> const& constructor = __jakt_match_value.constructor;
+{
+if (((!(((constructor).has_value()))) || (!((((constructor.value())).equals(open_for_writing)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot write to a file not opened for writing"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("expected struct as this argument"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+NonnullRefPtr<File> file = TRY((File::open_for_writing(path)));
+JaktInternal::DynamicArray<types::Value> data_values = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::Value>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(values);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::write` expects a `[u8]` as its argument, but got {}"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+JaktInternal::DynamicArray<u8> data = (TRY((DynamicArray<u8>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::Value> _magic = ((data_values).iterator());
+for (;;){
+JaktInternal::Optional<types::Value> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::Value val = (_magic_value.value());
+{
+TRY((((data).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((val).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("expected byte"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))));
+}
+
+}
+}
+
+size_t const bytes_written = TRY((((file)->write(data))));
+__jakt_var_218 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(bytes_written))),call_span)) } ; goto __jakt_label_204;
+
+}
+__jakt_label_204:; __jakt_var_218.release_value(); }));
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `File::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("StringBuilder"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("create"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_219; {
+types::StructId const string_builder_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("StringBuilder"sv)))));
+__jakt_var_219 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(Jakt::DeprecatedString(""sv)))),call_span)})))),string_builder_struct_id,JaktInternal::OptionalNone()))),call_span)) } ; goto __jakt_label_205;
+
+}
+__jakt_label_205:; __jakt_var_219.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_220; {
+JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString> fields_current_string_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((Tuple{fields, value}));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+JaktInternal::DynamicArray<types::Value> fields = ((fields_current_string_).template get<0>());
+DeprecatedString current_string = ((fields_current_string_).template get<1>());
+
+DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+TRY((((builder).append_string(current_string))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
+return (TRY((((builder).append(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid use of StringBuilder::append({})"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
+return (TRY((((builder).append_string(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_string()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
+return (TRY((((builder).append_escaped_for_json(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_escaped_for_json()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
+return (TRY((((builder).append_code_point(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u32, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_code_point()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else {
+{
+abort();
+}
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((builder).to_string())))))),call_span));
+__jakt_var_220 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_206;
+
+}
+__jakt_label_206:; __jakt_var_220.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_221; {
+JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString> fields_current_string_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((Tuple{fields, value}));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
-int const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+JaktInternal::DynamicArray<types::Value> fields = ((fields_current_string_).template get<0>());
+DeprecatedString current_string = ((fields_current_string_).template get<1>());
+
+DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+TRY((((builder).append_string(current_string))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
+return (TRY((((builder).append(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
-int const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid use of StringBuilder::append({})"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
+return (TRY((((builder).append_string(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_string()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
+return (TRY((((builder).append_escaped_for_json(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
 case 13: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x != y)))));
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_escaped_for_json()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
+return (TRY((((builder).append_code_point(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u32, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_code_point()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else {
+{
+abort();
+}
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((builder).to_string())))))),call_span));
+__jakt_var_221 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_207;
+
+}
+__jakt_label_207:; __jakt_var_221.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_222; {
+JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString> fields_current_string_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((Tuple{fields, value}));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+));
+JaktInternal::DynamicArray<types::Value> fields = ((fields_current_string_).template get<0>());
+DeprecatedString current_string = ((fields_current_string_).template get<1>());
+
+DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+TRY((((builder).append_string(current_string))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
+return (TRY((((builder).append(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid use of StringBuilder::append({})"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
+return (TRY((((builder).append_string(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_string()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
+return (TRY((((builder).append_escaped_for_json(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_escaped_for_json()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
+return (TRY((((builder).append_code_point(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u32, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_code_point()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else {
+{
+abort();
+}
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((builder).to_string())))))),call_span));
+__jakt_var_222 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_208;
+
+}
+__jakt_label_208:; __jakt_var_222.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_223; {
+JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString> fields_current_string_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,DeprecatedString>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((Tuple{fields, value}));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+JaktInternal::DynamicArray<types::Value> fields = ((fields_current_string_).template get<0>());
+DeprecatedString current_string = ((fields_current_string_).template get<1>());
+
+DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+TRY((((builder).append_string(current_string))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("append"sv)) {
+return (TRY((((builder).append(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u8, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid use of StringBuilder::append({})"sv),((((arguments)[static_cast<i64>(0LL)])).impl)))),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_string"sv)) {
+return (TRY((((builder).append_string(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_string()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_escaped_for_json"sv)) {
+return (TRY((((builder).append_escaped_for_json(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_escaped_for_json()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("append_code_point"sv)) {
+return (TRY((((builder).append_code_point(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u32, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of StringBuilder::append_code_point()"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+))))))), JaktInternal::ExplicitValue<void>();
+}
+else {
+{
+abort();
+}
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((((builder).to_string())))))),call_span));
+__jakt_var_223 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_209;
+
+}
+__jakt_label_209:; __jakt_var_223.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("to_string"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x < y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[static_cast<i64>(0LL)])) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)),span)) } );
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
+else if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).is_empty())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("length"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((value).length())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of prelude StringBuilder"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("clear"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_224; {
+JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
+(((((mutable_fields)[static_cast<i64>(0LL)])).impl) = TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(Jakt::DeprecatedString(""sv)))));
+__jakt_var_224 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_210;
+
+}
+__jakt_label_210:; __jakt_var_224.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` expects a StringBuilder as its this argument"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
-};/*case end*/
-default: {
+}
+else {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `StringBuilder::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("Dictionary"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("Dictionary"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_225; {
+if ((((type_bindings).size()) != static_cast<size_t>(2ULL))){
+TRY((((*this).error(Jakt::DeprecatedString("Dictionary constructor expects two generic argumenst"sv),call_span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+types::StructId const dictionary_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(dictionary_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({(((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(0LL)]))).value()), (((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(1LL)]))).value())})))))))))));
+__jakt_var_225 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktDictionary>((TRY((DynamicArray<types::Value>::create_with({})))),(TRY((DynamicArray<types::Value>::create_with({})))),type_id))),call_span)) } ; goto __jakt_label_211;
+
+}
+__jakt_label_211:; __jakt_var_225.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("get"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_226; {
+JaktInternal::Optional<size_t> found_index = JaktInternal::OptionalNone();
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if (((((((keys)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
+(found_index = i);
+break;
+}
+}
+
+}
+}
+
+__jakt_var_226 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((found_index).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(((values)[(found_index.value())])))),call_span));
+}
+else {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span));
+}
+}()))
+) } ; goto __jakt_label_212;
+
+}
+__jakt_label_212:; __jakt_var_226.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::get()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("set"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_227; {
+JaktInternal::Optional<size_t> found_index = JaktInternal::OptionalNone();
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if (((((((keys)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
+(found_index = i);
+break;
+}
+}
+
+}
+}
+
+JaktInternal::DynamicArray<types::Value> mutable_keys = keys;
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+if (((found_index).has_value())){
+(((mutable_values)[(found_index.value())]) = ((arguments)[static_cast<i64>(1LL)]));
+}
+else {
+TRY((((mutable_keys).push(((arguments)[static_cast<i64>(0LL)])))));
+TRY((((mutable_values).push(((arguments)[static_cast<i64>(1LL)])))));
+}
+
+__jakt_var_227 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_213;
+
+}
+__jakt_label_213:; __jakt_var_227.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::set()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((((keys).is_empty()) && ((values).is_empty()))))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::is_empty()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("contains"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_228; {
+bool found = false;
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if (((((((keys)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
+(found = true);
+break;
+}
+}
+
+}
+}
+
+__jakt_var_228 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(found))),call_span)) } ; goto __jakt_label_214;
+
+}
+__jakt_label_214:; __jakt_var_228.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::contains()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("remove"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_229; {
+JaktInternal::Optional<size_t> found_index = JaktInternal::OptionalNone();
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if (((((((keys)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
+(found_index = i);
+break;
+}
+}
+
+}
+}
+
+if (((found_index).has_value())){
+JaktInternal::DynamicArray<types::Value> keys_without = (TRY((DynamicArray<types::Value>::create_with({}))));
+JaktInternal::DynamicArray<types::Value> values_without = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if ((i == (found_index.value()))){
+continue;
+}
+TRY((((keys_without).push(((keys)[i])))));
+TRY((((values_without).push(((values)[i])))));
+}
+
+}
+}
+
+JaktInternal::DynamicArray<types::Value> mutable_keys = keys;
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+((mutable_keys).shrink(static_cast<size_t>(0ULL)));
+((mutable_values).shrink(static_cast<size_t>(0ULL)));
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((keys_without).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+TRY((((mutable_keys).push(((keys_without)[i])))));
+TRY((((mutable_values).push(((values_without)[i])))));
+}
+
+}
+}
+
+}
+__jakt_var_229 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((found_index).has_value())))),call_span)) } ; goto __jakt_label_215;
+
+}
+__jakt_label_215:; __jakt_var_229.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::remove()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("ensure_capacity"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x <= y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& capacity = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_230; {
+JaktInternal::DynamicArray<types::Value> mutable_keys = keys;
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+TRY((((mutable_keys).ensure_capacity(capacity))));
+TRY((((mutable_values).ensure_capacity(capacity))));
+__jakt_var_230 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_216;
+
+}
+__jakt_label_216:; __jakt_var_230.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Dictionary::ensure_capacity must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -10291,424 +9941,474 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::ensure_capacity()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+)));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("capacity"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((keys).capacity())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::capacity()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("clear"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_231; {
+JaktInternal::DynamicArray<types::Value> mutable_keys = keys;
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+((mutable_keys).shrink(static_cast<size_t>(0ULL)));
+((mutable_values).shrink(static_cast<size_t>(0ULL)));
+__jakt_var_231 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_217;
+
+}
+__jakt_label_217:; __jakt_var_231.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::clear()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("size"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((keys).size())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::size()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("keys"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_232; {
+JaktInternal::DynamicArray<types::TypeId> const generics = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(args);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("expected generic instance"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+));
+__jakt_var_232 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = ((((generics).size()) == static_cast<size_t>(2ULL)));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_233; {
+types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({((generics)[static_cast<i64>(0LL)])})))))))))));
+__jakt_var_233 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(keys,type_id))),call_span)) } ; goto __jakt_label_219;
+
+}
+__jakt_label_219:; __jakt_var_233.release_value(); }));
+}
+else {
+{
+utility::panic(Jakt::DeprecatedString("dictionary should have 2 generic args. one for keys, one for values"sv));
+}
+}
+}()))
+; goto __jakt_label_218;
+
+}
+__jakt_label_218:; __jakt_var_232.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::keys()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("iterator"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 21: {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_234; {
+types::StructId const struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("DictionaryIterator"sv)))));
+__jakt_var_234 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({(this_argument.value()), types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(static_cast<size_t>(0ULL)))),call_span)})))),struct_id,JaktInternal::OptionalNone()))),call_span)) } ; goto __jakt_label_220;
+
+}
+__jakt_label_220:; __jakt_var_234.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Dictionary::iterator()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Dictionary::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("Array"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("iterator"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 20: {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_235; {
+types::StructId const struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("ArrayIterator"sv)))));
+__jakt_var_235 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({(this_argument.value()), types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(static_cast<size_t>(0ULL)))),call_span)})))),struct_id,JaktInternal::OptionalNone()))),call_span)) } ; goto __jakt_label_221;
+
+}
+__jakt_label_221:; __jakt_var_235.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::iterator()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("size"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_236; {
+__jakt_var_236 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((values).size())))),call_span)) } ; goto __jakt_label_222;
+
+}
+__jakt_label_222:; __jakt_var_236.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::size()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("push"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_237; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+TRY((((mutable_values).push(((arguments)[static_cast<i64>(0LL)])))));
+__jakt_var_237 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_223;
+
+}
+__jakt_label_223:; __jakt_var_237.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::push()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("push_values"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
-};/*case end*/
-default: {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_238; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+{
+JaktInternal::ArrayIterator<types::Value> _magic = ((values).iterator());
+for (;;){
+JaktInternal::Optional<types::Value> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::Value value = (_magic_value.value());
+{
+TRY((((mutable_values).push(value))));
+}
+
+}
 }
+
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+return (TRY((((*this).error(Jakt::DeprecatedString("Only argument to push_values needs to be another Array"sv),call_span))))), JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+));
+__jakt_var_238 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_224;
+
+}
+__jakt_label_224:; __jakt_var_238.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::push_values()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("pop"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x > y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_239; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+JaktInternal::Optional<types::Value> const value = ((mutable_values).pop());
+__jakt_var_239 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((value).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue((value.value())) } );
+}
+else {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span)) } );
+}
+}()))
+; goto __jakt_label_225;
+
+}
+__jakt_label_225:; __jakt_var_239.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::push()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)),span)) } );
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+else if (__jakt_enum_value == Jakt::DeprecatedString("first"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_240; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+JaktInternal::Optional<types::Value> const value = ((mutable_values).first());
+__jakt_var_240 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((value).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue((value.value())) } );
+}
+else {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span)) } );
+}
+}()))
+; goto __jakt_label_226;
+
+}
+__jakt_label_226:; __jakt_var_240.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::push()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("last"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_241; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+JaktInternal::Optional<types::Value> const value = ((mutable_values).last());
+__jakt_var_241 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((value).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue((value.value())) } );
+}
+else {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span)) } );
+}
+}()))
+; goto __jakt_label_227;
+
+}
+__jakt_label_227:; __jakt_var_241.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::push()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("contains"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
-};/*case end*/
-default: {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_242; {
+bool found = false;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+JaktInternal::ArrayIterator<types::Value> _magic = ((values).iterator());
+for (;;){
+JaktInternal::Optional<types::Value> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
+types::Value value = (_magic_value.value());
+{
+if (((((value).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
+(found = true);
+break;
+}
+}
+
+}
+}
+
+__jakt_var_242 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(found))),call_span)) } ; goto __jakt_label_228;
+
+}
+__jakt_label_228:; __jakt_var_242.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::contains()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((values).is_empty())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::is_empty()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("capacity"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_243; {
+__jakt_var_243 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((values).capacity())))),call_span)) } ; goto __jakt_label_229;
+
+}
+__jakt_label_229:; __jakt_var_243.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::capacity()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("ensure_capacity"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& capacity = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_244; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+TRY((((mutable_values).ensure_capacity(capacity))));
+__jakt_var_244 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_230;
+
+}
+__jakt_label_230:; __jakt_var_244.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Array::ensure_capacity must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -10716,41 +10416,38 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::ensure_capacity()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("add_capacity"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F32>();
-f32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& capacity = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_245; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+TRY((((mutable_values).add_capacity(capacity))));
+__jakt_var_245 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_231;
+
+}
+__jakt_label_231:; __jakt_var_245.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Array::add_capacity must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -10758,41 +10455,38 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::F64>();
-f64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::add_capacity()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("shrink"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
+size_t const& size = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_246; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+((mutable_values).shrink(size));
+__jakt_var_246 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_232;
+
+}
+__jakt_label_232:; __jakt_var_246.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Array::shrink must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -10800,461 +10494,481 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x >= y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Array::shrink()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-default: {
+}
+else {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Array::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)),span)) } );
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("ArrayIterator"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("next"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_247; {
+size_t const index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x & y))))))));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid ArrayIterator index configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
+__jakt_var_247 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x & y))))))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = ((((values).size()) > index));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_248; {
+(((mutable_fields)[static_cast<i64>(1LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(index,static_cast<size_t>(1ULL)))))),call_span));
+__jakt_var_248 = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(((values)[index])))),call_span); goto __jakt_label_234;
+
+}
+__jakt_label_234:; __jakt_var_248.release_value(); }));
+}
+else {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span));
+}
+}()))
+);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid ArrayIterator configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x & y)))));
+))) } ; goto __jakt_label_233;
+
+}
+__jakt_label_233:; __jakt_var_247.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid ArrayIterator configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `ArrayIterator::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("Range"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("next"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_249; {
+JaktInternal::DynamicArray<types::Value> fields = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::Value>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x & y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(fields);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Range::next()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+u64 const start = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
 case 6: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x & y))))))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 case 7: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
 i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x & y))))))));
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid type for comptime range"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
+));
+u64 const end = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 case 8: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
 i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x & y)))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
 i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x & y)))));
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
 size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x & y)))));
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid type for comptime range"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+));
+if ((start == end)){
+return ( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span)) } );
+}
+if ((start > end)){
+(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_sub<u64>(start,static_cast<u64>(1ULL)))))),call_span));
+}
+else {
+(((fields)[static_cast<i64>(0LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(start,static_cast<u64>(1ULL)))))),call_span));
+}
+
+__jakt_var_249 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(start))),call_span)))),call_span)) } ; goto __jakt_label_235;
+
 }
+__jakt_label_235:; __jakt_var_249.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("inclusive"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::StructId const& struct_id = __jakt_match_value.struct_id;
+JaktInternal::Optional<types::FunctionId> const& constructor = __jakt_match_value.constructor;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_250; {
+JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
+u64 const end = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
-}/*switch end*/
-}()
-)),span)) } );
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
 u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x | y))))))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
 u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x | y))))))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
 u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x | y)))));
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid type for comptime range"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x | y)))));
+));
+(((((mutable_fields)[static_cast<i64>(1LL)])).impl) = TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(end,static_cast<u64>(1ULL)))))));
+__jakt_var_250 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>(fields,struct_id,constructor))),(((this_argument.value())).span))) } ; goto __jakt_label_236;
+
+}
+__jakt_label_236:; __jakt_var_250.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Range::inclusive()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("exclusive"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x | y))))))));
+case 17: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue((this_argument.value())) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Range::exclusive()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Range::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("String"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x | y))))))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).is_empty())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("length"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x | y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((value).length())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("hash"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x | y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(((value).hash())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("substring"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+size_t const& start = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
 switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x | y)))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+size_t const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_251; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_251 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_237;
+
 }
+__jakt_label_237:; __jakt_var_251.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_252; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_252 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_238;
+
+}
+__jakt_label_238:; __jakt_var_252.release_value(); }));
 };/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_253; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_253 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_239;
+
 }
+__jakt_label_239:; __jakt_var_253.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-)),span)) } );
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_254; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_254 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_240;
+
+}
+__jakt_label_240:; __jakt_var_254.release_value(); }));
 };/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x ^ y))))))));
+u8 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_255; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_255 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_241;
+
+}
+__jakt_label_241:; __jakt_var_255.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11262,20 +10976,65 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& start = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
 switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_256; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_256 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_242;
+
+}
+__jakt_label_242:; __jakt_var_256.release_value(); }));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_257; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_257 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_243;
+
+}
+__jakt_label_243:; __jakt_var_257.release_value(); }));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_258; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_258 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_244;
+
+}
+__jakt_label_244:; __jakt_var_258.release_value(); }));
+};/*case end*/
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x ^ y))))))));
+u16 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_259; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_259 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_245;
+
+}
+__jakt_label_245:; __jakt_var_259.release_value(); }));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_260; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_260 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_246;
+
+}
+__jakt_label_246:; __jakt_var_260.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11285,81 +11044,63 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+u32 const& start = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x ^ y)))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_261; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_261 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_247;
+
 }
+__jakt_label_247:; __jakt_var_261.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x ^ y)))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+u64 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_262; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_262 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_248;
+
 }
+__jakt_label_248:; __jakt_var_262.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_263; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_263 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_249;
+
+}
+__jakt_label_249:; __jakt_var_263.release_value(); }));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x ^ y))))))));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_264; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_264 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_250;
+
+}
+__jakt_label_250:; __jakt_var_264.release_value(); }));
 };/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_265; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_265 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_251;
+
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x ^ y))))))));
+__jakt_label_251:; __jakt_var_265.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11367,41 +11108,65 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& start = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x ^ y)))));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_266; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_266 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_252;
+
+}
+__jakt_label_252:; __jakt_var_266.release_value(); }));
 };/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_267; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_267 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_253;
+
 }
+__jakt_label_253:; __jakt_var_267.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_268; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_268 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_254;
+
+}
+__jakt_label_254:; __jakt_var_268.release_value(); }));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x ^ y)))));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_269; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_269 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_255;
+
+}
+__jakt_label_255:; __jakt_var_269.release_value(); }));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_270; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_270 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_256;
+
+}
+__jakt_label_256:; __jakt_var_270.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11409,20 +11174,65 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& start = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
 switch(__jakt_match_variant.index()) {
 case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x ^ y)))));
+size_t const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_271; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_271 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_257;
+
+}
+__jakt_label_257:; __jakt_var_271.release_value(); }));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_272; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_272 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_258;
+
+}
+__jakt_label_258:; __jakt_var_272.release_value(); }));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_273; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_273 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_259;
+
+}
+__jakt_label_259:; __jakt_var_273.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_274; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_274 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_260;
+
+}
+__jakt_label_260:; __jakt_var_274.release_value(); }));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& length = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_275; {
+DeprecatedString const result = ((value).substring((infallible_integer_cast<size_t>((start))),(infallible_integer_cast<size_t>((length)))));
+__jakt_var_275 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(result))),call_span)) } ; goto __jakt_label_261;
+
+}
+__jakt_label_261:; __jakt_var_275.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11432,158 +11242,184 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::substring must be called with unsigned arguments"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x << y))))))));
+)));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("number"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& number = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& number = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& number = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+};/*case end*/
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x << y))))))));
+u16 const& number = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
 };/*case end*/
-default: {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& number = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& number = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& number = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::number((infallible_integer_cast<i64>((number))))))),call_span)) } );
+};/*case end*/
+case 12: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::number must not be called with a usize or u64"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x << y)))));
+case 5: {
+{
+TRY((((*this).error(Jakt::DeprecatedString("String::number must not be called with a usize or u64"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::number must be called with an integer"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("to_uint"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x << y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_276; {
+JaktInternal::Optional<u32> const result = ((value).to_uint());
+__jakt_var_276 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((result).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((result.value())))),call_span)))));
+}
+else {
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())));
+}
+}()))
+,call_span)) } ; goto __jakt_label_262;
+
+}
+__jakt_label_262:; __jakt_var_276.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("to_int"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x << y))))))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_277; {
+JaktInternal::Optional<i32> const result = ((value).to_int());
+__jakt_var_277 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((result).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((result.value())))),call_span)))));
+}
+else {
+return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())));
+}
+}()))
+,call_span)) } ; goto __jakt_label_263;
+
+}
+__jakt_label_263:; __jakt_var_277.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("is_whitespace"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x << y))))))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).is_whitespace())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("contains"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x << y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& arg = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).contains(arg))))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::contains must be called with a string"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11591,41 +11427,39 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x << y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("replace"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x << y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& replace = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& with = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(((value).replace(replace,with))))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::replace must be called with strings"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11635,74 +11469,61 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::replace must be called with strings"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x >> y))))))));
+)));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x >> y))))))));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("byte_at"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& index = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& index = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
 };/*case end*/
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x >> y)))));
+u32 const& index = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& index = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& index = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((value).byte_at((infallible_integer_cast<size_t>((index)))))))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::byte_at must be called with an unsigned integer"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11710,41 +11531,55 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x >> y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("split"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x >> y))))))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& c = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_278; {
+JaktInternal::DynamicArray<DeprecatedString> const values = ((value).split(c));
+JaktInternal::DynamicArray<types::Value> result = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((values).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+DeprecatedString value = (_magic_value.value());
+{
+TRY((((result).push(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(value))),call_span)))));
+}
+
+}
+}
+
+types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+__jakt_var_278 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(result,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } )})))))))))))))),call_span)) } ; goto __jakt_label_264;
+
+}
+__jakt_label_264:; __jakt_var_278.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::split must be called with a c_char"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11752,41 +11587,33 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x >> y))))))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("starts_with"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x >> y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& arg = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).starts_with(arg))))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::starts_with must be called with a string"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11794,41 +11621,33 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x >> y)))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("ends_with"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x >> y)))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& arg = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((value).ends_with(arg))))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::ends_with must be called with a string"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11838,32 +11657,36 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid String"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 16: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
+)));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("repeated"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_279; {
+if ((((arguments).size()) != static_cast<size_t>(2ULL))){
+TRY((((*this).error(Jakt::DeprecatedString("String::repeated must be called with a c_char and a usize"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+JaktInternal::Tuple<char,size_t> const character_count_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<char,size_t>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& arg = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<char,size_t>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(1LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((infallible_integer_cast<u8>(((x << y))))))));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& c = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((Tuple{arg, c}));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::repeated must be called with a usize"sv),((((arguments)[static_cast<i64>(1LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
@@ -11871,581 +11694,835 @@ return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretEr
 }()
 )));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>(((x << y))))))));
-};/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("String::repeated must be called with a c_char"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+char const character = ((character_count_).template get<0>());
+size_t const count = ((character_count_).template get<1>());
+
+__jakt_var_279 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(DeprecatedString::repeated(character,count)))),call_span)) } ; goto __jakt_label_265;
+
+}
+__jakt_label_265:; __jakt_var_279.release_value(); }));
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `String::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("Set"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("Set"sv)) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_280; {
+if ((((type_bindings).size()) != static_cast<size_t>(1ULL))){
+TRY((((*this).error(Jakt::DeprecatedString("Set constructor expects one generic argument"sv),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+types::StructId const set_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Set"sv)))));
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(set_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({(((type_bindings).get(((TRY((((type_bindings).keys()))))[static_cast<i64>(0LL)]))).value())})))))))))));
+__jakt_var_280 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktSet>((TRY((DynamicArray<types::Value>::create_with({})))),type_id))),call_span)) } ; goto __jakt_label_266;
+
+}
+__jakt_label_266:; __jakt_var_280.release_value(); }));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("is_empty"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((x << y)))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((values).is_empty())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("contains"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((x << y)))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_281; {
+bool found = false;
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((values).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if (((((((values)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
+(found = true);
+break;
+}
+}
+
+}
+}
+
+__jakt_var_281 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(found))),call_span)) } ; goto __jakt_label_267;
+
+}
+__jakt_label_267:; __jakt_var_281.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("add"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((infallible_integer_cast<i8>(((x << y))))))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_282; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+TRY((((mutable_values).push(((arguments)[static_cast<i64>(0LL)])))));
+__jakt_var_282 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_268;
+
+}
+__jakt_label_268:; __jakt_var_282.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("remove"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>(((x << y))))))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_283; {
+bool found = false;
+JaktInternal::DynamicArray<types::Value> values_without = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((values).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if (((((((values)[i])).impl))->equals(((((arguments)[static_cast<i64>(0LL)])).impl)))){
+(found = true);
+continue;
+}
+TRY((((values_without).push(((values)[i])))));
+}
+
+}
+}
+
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+((mutable_values).shrink(static_cast<size_t>(0ULL)));
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((values_without).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+TRY((((mutable_values).push(((values_without)[i])))));
+}
+
+}
+}
+
+__jakt_var_283 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(found))),call_span)) } ; goto __jakt_label_269;
+
+}
+__jakt_label_269:; __jakt_var_283.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("clear"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((x << y)))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_284; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+((mutable_values).shrink(static_cast<size_t>(0ULL)));
+__jakt_var_284 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_270;
+
+}
+__jakt_label_270:; __jakt_var_284.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("size"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((x << y)))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((values).size())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("capacity"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((x << y)))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(((values).capacity())))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("ensure_capacity"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((arguments)[static_cast<i64>(0LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& capacity = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_285; {
+JaktInternal::DynamicArray<types::Value> mutable_values = values;
+TRY((((mutable_values).ensure_capacity(capacity))));
+__jakt_var_285 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } ; goto __jakt_label_271;
+
+}
+__jakt_label_271:; __jakt_var_285.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Set::ensure_capacity must be called with a usize"sv),((((arguments)[static_cast<i64>(0LL)])).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 17: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(JaktInternal::arithmetic_shift_right(x,y)))));
+)));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Set"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("iterator"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>(JaktInternal::arithmetic_shift_right(x,y)))));
+case 22: {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_286; {
+types::StructId const struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("SetIterator"sv)))));
+__jakt_var_286 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({(this_argument.value()), types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(static_cast<size_t>(0ULL)))),call_span)})))),struct_id,JaktInternal::OptionalNone()))),call_span)) } ; goto __jakt_label_272;
+
+}
+__jakt_label_272:; __jakt_var_286.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid use of Set::iterator()"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Set::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("SetIterator"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("next"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(JaktInternal::arithmetic_shift_right(x,y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_287; {
+size_t const index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid SetIterator index configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
+__jakt_var_287 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(JaktInternal::arithmetic_shift_right(x,y)))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = ((((values).size()) > index));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_288; {
+(((mutable_fields)[static_cast<i64>(1LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(index,static_cast<size_t>(1ULL)))))),call_span));
+__jakt_var_288 = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(((values)[index])))),call_span); goto __jakt_label_274;
+
+}
+__jakt_label_274:; __jakt_var_288.release_value(); }));
+}
+else {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span));
+}
+}()))
+);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid SetIterator configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>(JaktInternal::arithmetic_shift_right(x,y)))));
+))) } ; goto __jakt_label_273;
+
+}
+__jakt_label_273:; __jakt_var_287.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid SetIterator configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `ArrayIterator::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("DictionaryIterator"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("next"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>(JaktInternal::arithmetic_shift_right(x,y)))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_289; {
+size_t const index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(1LL)])).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid DictionaryIterator index configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+));
+JaktInternal::DynamicArray<types::Value> mutable_fields = fields;
+__jakt_var_289 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((fields)[static_cast<i64>(0LL)])).impl);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(JaktInternal::arithmetic_shift_right(x,y)))));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();JaktInternal::DynamicArray<types::Value> const& keys = __jakt_match_value.keys;
+JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((((keys).size()) > index) && (((values).size()) > index)));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_290; {
+(((mutable_fields)[static_cast<i64>(1LL)]) = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(index,static_cast<size_t>(1ULL)))))),call_span));
+JaktInternal::DynamicArray<types::TypeId> const generics = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(args);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("expected generic instance"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>(JaktInternal::arithmetic_shift_right(x,y)))));
+));
+types::StructId const tuple_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
+types::TypeId const tuple_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(tuple_struct_id,generics)))))));
+__jakt_var_290 = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktTuple>((TRY((DynamicArray<types::Value>::create_with({((keys)[index]), ((values)[index])})))),tuple_type_id))),call_span)))),call_span); goto __jakt_label_276;
+
+}
+__jakt_label_276:; __jakt_var_290.release_value(); }));
+}
+else {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),call_span));
+}
+}()))
+);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid DictionaryIterator configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(JaktInternal::arithmetic_shift_right(x,y)))));
+))) } ; goto __jakt_label_275;
+
+}
+__jakt_label_275:; __jakt_var_289.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid DictionaryIterator configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `DictionaryIterator::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("Optional"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (prelude_function);
+if (__jakt_enum_value == Jakt::DeprecatedString("has_value"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 24: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(true))),call_span)) } );
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(false))),call_span)) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Optional configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 19: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
-bool const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+)));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("value"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
 switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
-bool const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x || y)))));
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+};/*case end*/
+case 25: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot unwrap optional none"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::UnwrapOptionalNone))));
+}
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Optional configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("value_or"sv)) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *(((this_argument.value())).impl);
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((arguments)[static_cast<i64>(0LL)])) } );
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid Optional configuration"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 18: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
-bool const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((rhs_value).impl);
+)));
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `Optional::{}` is not implemented"sv),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+else {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Prelude function `{}::{}` is not implemented"sv),((((namespace_)[static_cast<i64>(0LL)])).name),prelude_function))),call_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+);
+}
+}
+
+interpreter::Interpreter::Interpreter(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, JaktInternal::DynamicArray<utility::Span> a_spans, JaktInternal::Dictionary<DeprecatedString,types::Value> a_reflected_type_cache, JaktInternal::Set<DeprecatedString> a_seen_reflected_types, JaktInternal::Optional<types::FunctionId> a_current_function_id, NonnullRefPtr<types::TypecheckFunctions> a_typecheck_functions): compiler(move(a_compiler)), program(move(a_program)), spans(move(a_spans)), reflected_type_cache(move(a_reflected_type_cache)), seen_reflected_types(move(a_seen_reflected_types)), current_function_id(move(a_current_function_id)), typecheck_functions(move(a_typecheck_functions)){}
+ErrorOr<NonnullRefPtr<Interpreter>> interpreter::Interpreter::__jakt_create(NonnullRefPtr<compiler::Compiler> compiler, NonnullRefPtr<types::CheckedProgram> program, JaktInternal::DynamicArray<utility::Span> spans, JaktInternal::Dictionary<DeprecatedString,types::Value> reflected_type_cache, JaktInternal::Set<DeprecatedString> seen_reflected_types, JaktInternal::Optional<types::FunctionId> current_function_id, NonnullRefPtr<types::TypecheckFunctions> typecheck_functions) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Interpreter (move(compiler), move(program), move(spans), move(reflected_type_cache), move(seen_reflected_types), move(current_function_id), move(typecheck_functions)))); return o; }
+ErrorOr<types::CheckedBlock> interpreter::Interpreter::typecheck_block(parser::ParsedBlock const block,types::ScopeId const scope) {
+{
+return (TRY((interpreter::Interpreter::invoke_typecheck_block(((((((*this).typecheck_functions))->block))),block,scope))));
+}
+}
+
+ErrorOr<JaktInternal::DynamicArray<types::Value>> interpreter::Interpreter::reflect_sum_enum_variants(types::CheckedEnum const subject_enum,utility::Span const span,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
+{
+types::EnumId const sum_enum_variant_enum_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
+auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("SumEnumVariant"sv)))));
 switch(__jakt_match_variant.index()) {
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
-bool const& y = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((x && y)))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(id);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Expected SumEnumVariant to be an enum"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
+));
+types::FunctionId const typed_variant_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(sum_enum_variant_enum_id))).scope_id),Jakt::DeprecatedString("Typed"sv))))).value());
+types::FunctionId const struct_like_variant_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(sum_enum_variant_enum_id))).scope_id),Jakt::DeprecatedString("StructLike"sv))))).value());
+types::FunctionId const untyped_variant_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(sum_enum_variant_enum_id))).scope_id),Jakt::DeprecatedString("Untyped"sv))))).value());
+types::StructId const field_struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::StructId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
+auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Field"sv)))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(id);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operands '{}' and '{}' to binary operation"sv),((lhs_value).type_name()),((rhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Expected Field to be a struct"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)),span)) } );
-};/*case end*/
-case 21: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(rhs_value) } );
-};/*case end*/
-case 22: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseAnd() } ,span,scope)))));
-};/*case end*/
-case 23: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseOr() } ,span,scope)))));
-};/*case end*/
-case 24: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseXor() } ,span,scope)))));
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseLeftShift() } ,span,scope)))));
-};/*case end*/
-case 26: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::BitwiseRightShift() } ,span,scope)))));
-};/*case end*/
-case 27: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Add() } ,span,scope)))));
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Subtract() } ,span,scope)))));
-};/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Multiply() } ,span,scope)))));
+));
+JaktInternal::DynamicArray<types::Value> result = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((subject_enum).variants)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedEnumVariant variant = (_magic_value.value());
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+{
+types::Value const type_value = TRY((((*this).reflect_type(type_id,span,scope))));
+types::Value const variant_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>((TRY((DynamicArray<types::Value>::create_with({TRY((((*this).string_value(name,span)))), type_value})))),sum_enum_variant_enum_id,typed_variant_constructor))),span);
+TRY((((result).push(variant_value))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Modulo() } ,span,scope)))));
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
+{
+types::Value const variant_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>((TRY((DynamicArray<types::Value>::create_with({TRY((((*this).string_value(name,span))))})))),sum_enum_variant_enum_id,untyped_variant_constructor))),span);
+TRY((((result).push(variant_value))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue(TRY((((*this).execute_binary_operator(lhs_value,rhs_value, parser::BinaryOperator { typename parser::BinaryOperator::Divide() } ,span,scope)))));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
+{
+JaktInternal::DynamicArray<types::Value> const reflected_fields = TRY((((*this).reflect_fields(fields,span,scope))));
+types::Value const variant_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>((TRY((DynamicArray<types::Value>::create_with({TRY((((*this).string_value(name,span)))), TRY((((*this).array_value_of_type(reflected_fields,TRY((((*this).array_type_of_struct(field_struct_id)))),span))))})))),sum_enum_variant_enum_id,struct_like_variant_constructor))),span);
+TRY((((result).push(variant_value))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unimplemented binary operator '{}'"sv),op))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
+));
+}
+
 }
 }
 
-ErrorOr<types::TypeId> interpreter::Interpreter::array_type_of_struct(types::StructId const struct_id) {
-{
-types::StructId const array_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-NonnullRefPtr<typename types::Type> const type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({((((((*this).program))->get_struct(struct_id))).type_id)})))))));
-return (TRY((((*this).find_or_add_type_id(type)))));
+return (result);
 }
 }
 
-ErrorOr<types::TypeId> interpreter::Interpreter::find_or_add_type_id(NonnullRefPtr<typename types::Type> const type) {
+ErrorOr<interpreter::StatementResult> interpreter::Interpreter::execute_statement(NonnullRefPtr<typename types::CheckedStatement> const statement,NonnullRefPtr<interpreter::InterpreterScope> scope,utility::Span const call_span) {
 {
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *statement;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> _magic = ((((((*this).program))->modules)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<types::Module>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (TRY((((*this).execute_expression(expr,scope)))));
 }
-NonnullRefPtr<types::Module> module = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.statement;
+{
+TRY((((scope)->defer_statement(statement))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& vars = __jakt_match_value.vars;
+NonnullRefPtr<typename types::CheckedStatement> const& var_decl = __jakt_match_value.var_decl;
 {
+if (((var_decl)->index() == 3 /* VarDecl */)){
+types::VarId const var_id = ((var_decl)->get<types::CheckedStatement::VarDecl>()).var_id;
+NonnullRefPtr<typename types::CheckedExpression> const init = ((var_decl)->get<types::CheckedStatement::VarDecl>()).init;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(init,scope))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((module)->types)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-size_t id = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
 {
-if (((((((module)->types))[id]))->equals(type))){
-return (types::TypeId(((module)->id),id));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& var_value = __jakt_match_value.value;
+{
+TRY(((scope)->bindings).set(((((((*this).program))->get_variable(var_id)))->name), var_value));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 4: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((vars).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename types::CheckedStatement> var = (_magic_value.value());
+{
+if (((var)->index() == 3 /* VarDecl */)){
+types::VarId const var_id = ((var)->get<types::CheckedStatement::VarDecl>()).var_id;
+NonnullRefPtr<typename types::CheckedExpression> const init = ((var)->get<types::CheckedStatement::VarDecl>()).init;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(init,scope))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-
-TRY((((((((((((*this).program))->modules))[static_cast<i64>(0LL)]))->types)).push(type))));
-return (types::TypeId(types::ModuleId(static_cast<size_t>(0ULL)),(JaktInternal::checked_sub<size_t>(((((((((((*this).program))->modules))[static_cast<i64>(0LL)]))->types)).size()),static_cast<size_t>(1ULL)))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& var_value = __jakt_match_value.value;
+{
+TRY(((scope)->bindings).set(((((((*this).program))->get_variable(var_id)))->name), var_value));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-
-void interpreter::Interpreter::leave_span() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 4: {
 {
-JaktInternal::Optional<utility::Span> const dummy = ((((*this).spans)).pop());
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
 }
+else {
+utility::panic(Jakt::DeprecatedString("expected vardecl"sv));
+}
+
 }
 
-ErrorOr<void> interpreter::Interpreter::error(DeprecatedString const message,utility::Span const span) {
-{
-TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::Message(message,span) } ))));
-TRY((((((*this).compiler))->print_errors())));
 }
-return {};
 }
 
-ErrorOr<NonnullRefPtr<interpreter::Interpreter>> interpreter::Interpreter::create(NonnullRefPtr<compiler::Compiler> const compiler,NonnullRefPtr<types::CheckedProgram> const program,NonnullRefPtr<types::TypecheckFunctions> const typecheck_functions,JaktInternal::DynamicArray<utility::Span> const spans) {
-{
-return (TRY((interpreter::Interpreter::__jakt_create(compiler,program,spans,(TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),(TRY((Set<DeprecatedString>::create_with_values({})))),JaktInternal::OptionalNone(),typecheck_functions))));
 }
+else {
+utility::panic(Jakt::DeprecatedString("expected vardecl"sv));
 }
 
-ErrorOr<interpreter::StatementResult> interpreter::Interpreter::execute_expression_without_cast(NonnullRefPtr<typename types::CheckedExpression> const expr,NonnullRefPtr<interpreter::InterpreterScope> scope) {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *expr;
-switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& lhs = __jakt_match_value.lhs;
-parser::BinaryOperator const& op = __jakt_match_value.op;
-NonnullRefPtr<typename types::CheckedExpression> const& rhs = __jakt_match_value.rhs;
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();types::VarId const& var_id = __jakt_match_value.var_id;
+NonnullRefPtr<typename types::CheckedExpression> const& init = __jakt_match_value.init;
 utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_291; {
-types::Value const lhs_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(lhs,scope))));
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(init,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -12453,6 +12530,7 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -12460,43 +12538,70 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+types::Value const& var_value = __jakt_match_value.value;
+{
+TRY(((scope)->bindings).set(((((((*this).program))->get_variable(var_id)))->name), var_value));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-interpreter::StatementResult const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 20: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& then_block = __jakt_match_value.then_block;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
+utility::Span const& span = __jakt_match_value.span;
+{
+bool const cond = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(condition,scope))));
 switch(__jakt_match_variant.index()) {
-case 25: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
 switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
+bool const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("if condition must be a boolean, but got {}"sv),((value).impl)))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
@@ -12511,11 +12616,6 @@ types::Value const& value = __jakt_match_value.value;
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
-};/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
@@ -12527,36 +12627,86 @@ return ( interpreter::StatementResult { typename interpreter::StatementResult::B
 }
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)));
+));
+JaktInternal::Optional<types::CheckedBlock> const block = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::CheckedBlock>,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (cond);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::CheckedBlock>>(then_block));
+}
+else {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::CheckedBlock>,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((else_statement).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::CheckedBlock>>(types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({(else_statement.value())})))),((then_block).scope_id), types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,JaktInternal::OptionalNone(),false)));
+}
+else {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+}
+}()))
+);
+}
+}()))
+;
+if (((block).has_value())){
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_block((block.value()),scope,span))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 };/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 };/*case end*/
-default: {
+case 5: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),span)) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+};/*case end*/
+case 2: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid left-hand side of NoneCoalescing"sv));
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-))) } );
+)));
+}
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 32: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 25: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+{
+NonnullRefPtr<interpreter::InterpreterScope> new_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
+ScopeGuard __jakt_var_291([&] {
+MUST((((new_scope)->perform_defers(*this,span))));
+});
+return (TRY((((*this).execute_block(block,new_scope,span)))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+{
+for (;;){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_block(block,scope,span))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -12564,6 +12714,7 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -12571,58 +12722,46 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 3: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+return JaktInternal::LoopContinue{};
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 5: {
+{
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)));
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
-};/*case end*/
-default: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid left-hand side of NoneCoalescing"sv));
+));
 }
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-))) } );
-};/*case end*/
-case 18: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
-bool const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (x);
-if (__jakt_enum_value == ((op).index() == 18 /* LogicalAnd */)) {
-return JaktInternal::ExplicitValue(TRY((((JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+{
+for (;;){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(condition,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -12630,6 +12769,7 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -12637,61 +12777,44 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& x = __jakt_match_value.value;
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+if (((((x).impl))->index() == 1 /* Bool */)){
+bool const cond = ((((x).impl))->get<types::ValueImpl::Bool>()).value;
+if ((!(cond))){
+return JaktInternal::LoopBreak{};
 }
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-))).cast(lhs_value,span)))));
 }
-else {
-return JaktInternal::ExplicitValue(lhs_value);
 }
-}()))
-);
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 2: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operand '{}' to binary operation"sv),((lhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-))) } );
-};/*case end*/
-case 19: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((lhs_value).impl);
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
-bool const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (x);
-if (__jakt_enum_value == ((op).index() == 18 /* LogicalAnd */)) {
-return JaktInternal::ExplicitValue(TRY((((JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
+));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_block(block,scope,span))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -12699,6 +12822,7 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -12706,880 +12830,730 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 3: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+return JaktInternal::LoopContinue{};
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 5: {
+{
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-))).cast(lhs_value,span)))));
+));
 }
-else {
-return JaktInternal::ExplicitValue(lhs_value);
 }
-}()))
-);
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& val = __jakt_match_value.val;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operand '{}' to binary operation"sv),((lhs_value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-))) } );
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_292; {
-types::Value const rhs_value = TRY((((JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
+if (((val).has_value())){
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression((val.value()),scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
-}
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
 types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-}
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 };/*case end*/
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
 types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 };/*case end*/
 case 3: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
-}
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 };/*case end*/
 case 4: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
-}
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-))).cast(lhs_value,span))));
-__jakt_var_292 = TRY((((*this).execute_binary_operator(lhs_value,rhs_value,op,span,scope)))); goto __jakt_label_280;
-
+)));
+}
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } );
 }
-__jakt_label_280:; __jakt_var_292.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = value;
+case 9: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 10: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
 types::Value const& value = __jakt_match_value.value;
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 21: {
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Yield(value) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 22: {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 23: {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 24: {
+case 3: {
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 25: {
+case 4: {
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 26: {
+case 2: {
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 27: {
-{
-TRY((((*this).update_binding(lhs,scope,value,span))));
-}
-return JaktInternal::ExplicitValue<void>();
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+))), JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 28: {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 29: {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 30: {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 31: {
+case 3: {
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 32: {
+case 4: {
 {
-TRY((((*this).update_binding(lhs,scope,value,span))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 2: {
 {
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ))), JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::InlineCpp>();utility::Span const& span = __jakt_match_value.span;
+return (TRY((((*this).error(Jakt::DeprecatedString("Cannot run inline cpp at compile time"sv),span))))), JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedStatement::Garbage>();
+utility::Span const& span = __jakt_match_value.value;
+return (TRY((((*this).error(Jakt::DeprecatedString("Cannot run invalid statements at compile time"sv),span))))), JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-__jakt_var_291 = value; goto __jakt_label_279;
-
+return ( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } );
 }
-__jakt_label_279:; __jakt_var_291.release_value(); }));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedUnaryOperator const& op = __jakt_match_value.op;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = op;
+}
+
+ErrorOr<void> interpreter::Interpreter::update_binding(NonnullRefPtr<typename types::CheckedExpression> const binding,NonnullRefPtr<interpreter::InterpreterScope> scope,types::Value const value,utility::Span const span) {
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = *binding;
 switch(__jakt_match_variant.index()) {
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::Sizeof>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(TRY((interpreter::size_of_impl(type_id,*this)))))),span)) } );
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
+{
+TRY((((scope)->set(((var)->name),value))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_293; {
-types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+DeprecatedString const& index = __jakt_match_value.index;
+{
+JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::StructId> fields_struct_id_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::StructId>, ErrorOr<void>>{
 auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
 types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
-}
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::StructId>, ErrorOr<void>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Class>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::StructId const& struct_id = __jakt_match_value.struct_id;
+return JaktInternal::ExplicitValue((Tuple{fields, struct_id}));
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::StructId const& struct_id = __jakt_match_value.struct_id;
+return JaktInternal::ExplicitValue((Tuple{fields, struct_id}));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
+default: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+utility::panic(Jakt::DeprecatedString("Invalid left-hand side in assignment"sv));
 }
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 3: {
+default: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+utility::panic(Jakt::DeprecatedString("Should not be happening here"sv));
 }
 };/*case end*/
-case 4: {
+}/*switch end*/
+}()
+));
+JaktInternal::DynamicArray<types::Value> fields = ((fields_struct_id_).template get<0>());
+types::StructId struct_id = ((fields_struct_id_).template get<1>());
+
+JaktInternal::DynamicArray<types::CheckedField> const field_decls = ((((((*this).program))->get_struct(struct_id))).fields);
+size_t field_index = static_cast<size_t>(0ULL);
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((field_decls).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
+size_t i = (_magic_value.value());
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+if ((((((((*this).program))->get_variable(((((field_decls)[i])).variable_id))))->name) == index)){
+(field_index = i);
+break;
+}
+}
+
+}
+}
+
+(((fields)[field_index]) = value);
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-__jakt_var_293 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = op;
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+DeprecatedString const& index = __jakt_match_value.index;
+{
+JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::EnumId> fields_enum_id_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::EnumId>, ErrorOr<void>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
-case 9: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::DynamicArray<types::Value>,types::EnumId>, ErrorOr<void>>{
 auto&& __jakt_match_variant = *((value).impl);
 switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
-bool const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((!(value))))),span)) } );
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::EnumId const& enum_id = __jakt_match_value.enum_id;
+return JaktInternal::ExplicitValue((Tuple{fields, enum_id}));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid left-hand side in assignment"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_294; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_add<u8>(x,static_cast<u8>(1)))))),span),span))));
-__jakt_var_294 = value; goto __jakt_label_282;
-
+default: {
+{
+utility::panic(Jakt::DeprecatedString("Should not be happening here"sv));
 }
-__jakt_label_282:; __jakt_var_294.release_value(); }));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_295; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_add<i8>(x,static_cast<i8>(1)))))),span),span))));
-__jakt_var_295 = value; goto __jakt_label_283;
+}/*switch end*/
+}()
+));
+JaktInternal::DynamicArray<types::Value> fields = ((fields_enum_id_).template get<0>());
+types::EnumId enum_id = ((fields_enum_id_).template get<1>());
 
+JaktInternal::DynamicArray<types::CheckedField> const field_decls = ((((((*this).program))->get_enum(enum_id))).fields);
+size_t field_index = static_cast<size_t>(0ULL);
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((field_decls).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_283:; __jakt_var_295.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_296; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_add<u16>(x,static_cast<u16>(1)))))),span),span))));
-__jakt_var_296 = value; goto __jakt_label_284;
-
+size_t i = (_magic_value.value());
+{
+if ((((((((*this).program))->get_variable(((((field_decls)[i])).variable_id))))->name) == index)){
+(field_index = i);
+break;
 }
-__jakt_label_284:; __jakt_var_296.release_value(); }));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_297; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_add<i16>(x,static_cast<i16>(1)))))),span),span))));
-__jakt_var_297 = value; goto __jakt_label_285;
-
 }
-__jakt_label_285:; __jakt_var_297.release_value(); }));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_298; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_add<u32>(x,static_cast<u32>(1)))))),span),span))));
-__jakt_var_298 = value; goto __jakt_label_286;
 
 }
-__jakt_label_286:; __jakt_var_298.release_value(); }));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_299; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_add<i32>(x,static_cast<i32>(1)))))),span),span))));
-__jakt_var_299 = value; goto __jakt_label_287;
-
 }
-__jakt_label_287:; __jakt_var_299.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_300; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(x,static_cast<u64>(1ULL)))))),span),span))));
-__jakt_var_300 = value; goto __jakt_label_288;
 
+(((fields)[field_index]) = value);
 }
-__jakt_label_288:; __jakt_var_300.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_301; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_add<i64>(x,static_cast<i64>(1LL)))))),span),span))));
-__jakt_var_301 = value; goto __jakt_label_289;
-
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid left-hand side of assignment {}"sv),binding))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_289:; __jakt_var_301.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_302; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((JaktInternal::checked_add<char>(x,static_cast<char>(1)))))),span),span))));
-__jakt_var_302 = value; goto __jakt_label_290;
-
+}/*switch end*/
+}()
+));
 }
-__jakt_label_290:; __jakt_var_302.release_value(); }));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
-int const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_303; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((JaktInternal::checked_add<int>(x,static_cast<size_t>(1ULL)))))),span),span))));
-__jakt_var_303 = value; goto __jakt_label_291;
-
+return {};
 }
-__jakt_label_291:; __jakt_var_303.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_304; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(x,static_cast<size_t>(1ULL)))))),span),span))));
-__jakt_var_304 = value; goto __jakt_label_292;
 
-}
-__jakt_label_292:; __jakt_var_304.release_value(); }));
+ErrorOr<JaktInternal::DynamicArray<types::Value>> interpreter::Interpreter::reflect_fields(JaktInternal::DynamicArray<types::VarId> const fields,utility::Span const span,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
+{
+types::StructId const field_struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::StructId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
+auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Field"sv)))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(id);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Expected Field to be a struct"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-))) } );
+));
+types::FunctionId const field_struct_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_struct(field_struct_id))).scope_id),Jakt::DeprecatedString("Field"sv))))).value());
+types::EnumId const visibility_enum_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
+auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Visibility"sv)))));
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(id);
 };/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
+default: {
+{
+utility::panic(Jakt::DeprecatedString("Expected Visibility to be an enum"sv));
+}
+};/*case end*/
+}/*switch end*/
+}()
+));
+types::FunctionId const visibility_public_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(visibility_enum_id))).scope_id),Jakt::DeprecatedString("Public"sv))))).value());
+types::FunctionId const visibility_private_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_enum(visibility_enum_id))).scope_id),Jakt::DeprecatedString("Private"sv))))).value());
+types::StructId const variable_declaration_struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::StructId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
+auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("VariableDeclaration"sv)))));
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_305; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_add<u8>(x,static_cast<u8>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_305 = value; goto __jakt_label_293;
-
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(id);
+};/*case end*/
+default: {
+{
+utility::panic(Jakt::DeprecatedString("Expected VariableDeclaration to be a struct"sv));
+}
+};/*case end*/
+}/*switch end*/
+}()
+));
+types::FunctionId const variable_declaration_struct_constructor = (TRY((((((*this).program))->find_function_in_scope(((((((*this).program))->get_struct(variable_declaration_struct_id))).scope_id),Jakt::DeprecatedString("VariableDeclaration"sv))))).value());
+JaktInternal::DynamicArray<types::Value> record_type_fields = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
+for (;;){
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_293:; __jakt_var_305.release_value(); }));
+types::VarId var_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedVariable> const field = ((((*this).program))->get_variable(var_id));
+types::Value const variable = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(((field)->name)))),span), TRY((((*this).reflect_type(((field)->type_id),span,scope)))), types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(((field)->is_mutable)))),span)})))),variable_declaration_struct_id,variable_declaration_struct_constructor))),span);
+types::Value const field_value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({variable, types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>((TRY((DynamicArray<types::Value>::create_with({})))),visibility_enum_id,JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::FunctionId, ErrorOr<JaktInternal::DynamicArray<types::Value>>>{
+auto&& __jakt_match_variant = ((field)->visibility);
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(visibility_public_constructor);
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_306; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_add<i8>(x,static_cast<i8>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_306 = value; goto __jakt_label_294;
-
-}
-__jakt_label_294:; __jakt_var_306.release_value(); }));
+case 1: {
+return JaktInternal::ExplicitValue(visibility_private_constructor);
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_307; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_add<u16>(x,static_cast<u16>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_307 = value; goto __jakt_label_295;
-
+default: {
+{
+utility::panic(Jakt::DeprecatedString("Not implemented"sv));
 }
-__jakt_label_295:; __jakt_var_307.release_value(); }));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_308; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_add<i16>(x,static_cast<i16>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_308 = value; goto __jakt_label_296;
-
+}/*switch end*/
+}()
+))))),span)})))),field_struct_id,field_struct_constructor))),span);
+TRY((((record_type_fields).push(field_value))));
 }
-__jakt_label_296:; __jakt_var_308.release_value(); }));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_309; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_add<u32>(x,static_cast<u32>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_309 = value; goto __jakt_label_297;
 
 }
-__jakt_label_297:; __jakt_var_309.release_value(); }));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_310; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_add<i32>(x,static_cast<i32>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_310 = value; goto __jakt_label_298;
-
 }
-__jakt_label_298:; __jakt_var_310.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_311; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(x,static_cast<u64>(1ULL)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_311 = value; goto __jakt_label_299;
 
+return (record_type_fields);
 }
-__jakt_label_299:; __jakt_var_311.release_value(); }));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_312; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_add<i64>(x,static_cast<i64>(1LL)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_312 = value; goto __jakt_label_300;
-
 }
-__jakt_label_300:; __jakt_var_312.release_value(); }));
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_313; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((JaktInternal::checked_add<char>(x,static_cast<char>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_313 = value; goto __jakt_label_301;
 
+ErrorOr<void> interpreter::Interpreter::error(DeprecatedString const message,utility::Span const span) {
+{
+TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::Message(message,span) } ))));
+TRY((((((*this).compiler))->print_errors())));
+}
+return {};
 }
-__jakt_label_301:; __jakt_var_313.release_value(); }));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
-int const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_314; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((JaktInternal::checked_add<int>(x,static_cast<size_t>(1ULL)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_314 = value; goto __jakt_label_302;
 
+ErrorOr<types::Value> interpreter::Interpreter::string_value(DeprecatedString const string,utility::Span const span) {
+{
+return (types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(string))),span));
+}
 }
-__jakt_label_302:; __jakt_var_314.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_315; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(x,static_cast<size_t>(1ULL)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_315 = value; goto __jakt_label_303;
 
+ErrorOr<interpreter::StatementResult> interpreter::Interpreter::execute_expression_without_cast(NonnullRefPtr<typename types::CheckedExpression> const expr,NonnullRefPtr<interpreter::InterpreterScope> scope) {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *expr;
+switch(__jakt_match_variant.index()) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& lhs = __jakt_match_value.lhs;
+parser::BinaryOperator const& op = __jakt_match_value.op;
+NonnullRefPtr<typename types::CheckedExpression> const& rhs = __jakt_match_value.rhs;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_292; {
+types::Value const lhs_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(lhs,scope))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-__jakt_label_303:; __jakt_var_315.release_value(); }));
 };/*case end*/
-default: {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 };/*case end*/
-}/*switch end*/
-}()
-))) } );
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_316; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_sub<u8>(x,static_cast<u8>(1)))))),span),span))));
-__jakt_var_316 = value; goto __jakt_label_304;
-
-}
-__jakt_label_304:; __jakt_var_316.release_value(); }));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_317; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_sub<i8>(x,static_cast<i8>(1)))))),span),span))));
-__jakt_var_317 = value; goto __jakt_label_305;
-
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-__jakt_label_305:; __jakt_var_317.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_318; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_sub<u16>(x,static_cast<u16>(1)))))),span),span))));
-__jakt_var_318 = value; goto __jakt_label_306;
-
+case 4: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-__jakt_label_306:; __jakt_var_318.release_value(); }));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_319; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_sub<i16>(x,static_cast<i16>(1)))))),span),span))));
-__jakt_var_319 = value; goto __jakt_label_307;
-
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-__jakt_label_307:; __jakt_var_319.release_value(); }));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_320; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_sub<u32>(x,static_cast<u32>(1)))))),span),span))));
-__jakt_var_320 = value; goto __jakt_label_308;
-
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+interpreter::StatementResult const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 20: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 25: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-__jakt_label_308:; __jakt_var_320.release_value(); }));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_321; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_sub<i32>(x,static_cast<i32>(1)))))),span),span))));
-__jakt_var_321 = value; goto __jakt_label_309;
-
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-__jakt_label_309:; __jakt_var_321.release_value(); }));
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_322; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_sub<u64>(x,static_cast<u64>(1ULL)))))),span),span))));
-__jakt_var_322 = value; goto __jakt_label_310;
-
-}
-__jakt_label_310:; __jakt_var_322.release_value(); }));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_323; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_sub<i64>(x,static_cast<i64>(1LL)))))),span),span))));
-__jakt_var_323 = value; goto __jakt_label_311;
-
+case 3: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-__jakt_label_311:; __jakt_var_323.release_value(); }));
 };/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_324; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((JaktInternal::checked_sub<char>(x,static_cast<char>(1)))))),span),span))));
-__jakt_var_324 = value; goto __jakt_label_312;
-
+case 4: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-__jakt_label_312:; __jakt_var_324.release_value(); }));
 };/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
-int const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_325; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((JaktInternal::checked_sub<int>(x,static_cast<size_t>(1ULL)))))),span),span))));
-__jakt_var_325 = value; goto __jakt_label_313;
-
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-__jakt_label_313:; __jakt_var_325.release_value(); }));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_326; {
-TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_sub<size_t>(x,static_cast<size_t>(1ULL)))))),span),span))));
-__jakt_var_326 = value; goto __jakt_label_314;
-
-}
-__jakt_label_314:; __jakt_var_326.release_value(); }));
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid left-hand side of NoneCoalescing"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 ))) } );
 };/*case end*/
-case 2: {
+case 32: {
 return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_327; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_sub<u8>(x,static_cast<u8>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_327 = value; goto __jakt_label_315;
-
+case 25: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-__jakt_label_315:; __jakt_var_327.release_value(); }));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_328; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_sub<i8>(x,static_cast<i8>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_328 = value; goto __jakt_label_316;
-
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-__jakt_label_316:; __jakt_var_328.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_329; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_sub<u16>(x,static_cast<u16>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_329 = value; goto __jakt_label_317;
-
-}
-__jakt_label_317:; __jakt_var_329.release_value(); }));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_330; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_sub<i16>(x,static_cast<i16>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_330 = value; goto __jakt_label_318;
-
+case 3: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-__jakt_label_318:; __jakt_var_330.release_value(); }));
 };/*case end*/
 case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_331; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_sub<u32>(x,static_cast<u32>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_331 = value; goto __jakt_label_319;
-
-}
-__jakt_label_319:; __jakt_var_331.release_value(); }));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_332; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_sub<i32>(x,static_cast<i32>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_332 = value; goto __jakt_label_320;
-
-}
-__jakt_label_320:; __jakt_var_332.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_333; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_sub<u64>(x,static_cast<u64>(1ULL)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_333 = value; goto __jakt_label_321;
-
-}
-__jakt_label_321:; __jakt_var_333.release_value(); }));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_334; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_sub<i64>(x,static_cast<i64>(1LL)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_334 = value; goto __jakt_label_322;
-
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-__jakt_label_322:; __jakt_var_334.release_value(); }));
 };/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
-char const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_335; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((JaktInternal::checked_sub<char>(x,static_cast<char>(1)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_335 = value; goto __jakt_label_323;
-
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-__jakt_label_323:; __jakt_var_335.release_value(); }));
 };/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
-int const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_336; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((JaktInternal::checked_sub<int>(x,static_cast<size_t>(1ULL)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_336 = value; goto __jakt_label_324;
-
-}
-__jakt_label_324:; __jakt_var_336.release_value(); }));
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_337; {
-types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_sub<size_t>(x,static_cast<size_t>(1ULL)))))),span);
-TRY((((*this).update_binding(expr,scope,value,span))));
-__jakt_var_337 = value; goto __jakt_label_325;
-
-}
-__jakt_label_325:; __jakt_var_337.release_value(); }));
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid left-hand side of NoneCoalescing"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
 ))) } );
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::TypeCast>();
-types::CheckedTypeCast const& cast = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = cast;
+case 18: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
 switch(__jakt_match_variant.index()) {
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Infallible>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((interpreter::cast_value_to_type(value,type_id,*this,false)))) } );
-};/*case end*/
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
+bool const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (x);
+if (__jakt_enum_value == ((op).index() == 18 /* LogicalAnd */)) {
+return JaktInternal::ExplicitValue(TRY((((JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
+switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Fallible>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_338; {
-__jakt_var_338 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(TRY((interpreter::cast_value_to_type(value,type_id,*this,false)))))),span)) } ; goto __jakt_label_326;
-
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-__jakt_label_326:; __jakt_var_338.release_value(); }));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+}
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedUnaryOperator::IsEnumVariant>();types::CheckedEnumVariant const& enum_variant = __jakt_match_value.enum_variant;
-JaktInternal::DynamicArray<types::CheckedEnumVariantBinding> const& bindings = __jakt_match_value.bindings;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::FunctionId const& constructor = __jakt_match_value.constructor;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_339; {
-DeprecatedString const constructor_name = ((((((*this).program))->get_function(constructor)))->name);
-if ((((enum_variant).name()) != constructor_name)){
-return ( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(false))),span)) } );
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
+case 3: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-__jakt_var_339 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(true))),span)) } ; goto __jakt_label_327;
-
+};/*case end*/
+case 4: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-__jakt_label_327:; __jakt_var_339.release_value(); }));
 };/*case end*/
-default: {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid value for unary operator '{}'"sv),op))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)));
+))).cast(lhs_value,span)))));
+}
+else {
+return JaktInternal::ExplicitValue(lhs_value);
+}
+}()))
+);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unimplemented unary operator '{}'"sv),op))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_281;
-
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operand '{}' to binary operation"sv),((lhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_281:; __jakt_var_293.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
-)));
+))) } );
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& from = __jakt_match_value.from;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& to = __jakt_match_value.to;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_340; {
-types::Value const start = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((from).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression((from.value()),scope))));
+case 19: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((lhs_value).impl);
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
+bool const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (x);
+if (__jakt_enum_value == ((op).index() == 18 /* LogicalAnd */)) {
+return JaktInternal::ExplicitValue(TRY((((JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -13619,21 +13593,28 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)));
+))).cast(lhs_value,span)))));
 }
 else {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Partial ranges are not implemented"sv),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
+return JaktInternal::ExplicitValue(lhs_value);
 }
 }()))
-;
-types::Value const end = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((to).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression((to.value()),scope))));
+);
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid operand '{}' to binary operation"sv),((lhs_value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+))) } );
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_293; {
+types::Value const rhs_value = TRY((((JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(rhs,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -13673,40 +13654,134 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)));
+))).cast(lhs_value,span))));
+__jakt_var_293 = TRY((((*this).execute_binary_operator(lhs_value,rhs_value,op,span,scope)))); goto __jakt_label_278;
+
 }
-else {
+__jakt_label_278:; __jakt_var_293.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = value;
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 21: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Partial ranges are not implemented"sv),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+TRY((((*this).update_binding(lhs,scope,value,span))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 22: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
 }
-}()))
-;
-types::StructId const range_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Range"sv)))));
-JaktInternal::DynamicArray<types::FunctionId> const range_constructors = (TRY((((((*this).program))->find_functions_with_name_in_scope(((((((*this).program))->get_struct(range_struct_id))).scope_id),Jakt::DeprecatedString("Range"sv))))).value());
-__jakt_var_340 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({start, end})))),range_struct_id,((range_constructors)[static_cast<i64>(0LL)])))),span)) } ; goto __jakt_label_328;
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 23: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
 }
-__jakt_label_328:; __jakt_var_340.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_341; {
-if ((!(((((call).function_id)).has_value())))){
-JaktInternal::DynamicArray<types::Value> arguments = (TRY((DynamicArray<types::Value>::create_with({}))));
+case 24: {
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).update_binding(lhs,scope,value,span))));
 }
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 25: {
 {
-TRY((((arguments).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(((arg).template get<1>()),scope))));
+TRY((((*this).update_binding(lhs,scope,value,span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 26: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 27: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 28: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 29: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 30: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 31: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 32: {
+{
+TRY((((*this).update_binding(lhs,scope,value,span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+))), JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+__jakt_var_292 = value; goto __jakt_label_277;
+
+}
+__jakt_label_277:; __jakt_var_292.release_value(); }));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedUnaryOperator const& op = __jakt_match_value.op;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::Sizeof>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>(TRY((interpreter::size_of_impl(type_id,*this)))))),span)) } );
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_294; {
+types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -13746,441 +13821,627 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-))))));
+));
+__jakt_var_294 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 9: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
+bool const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>((!(value))))),span)) } );
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_295; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_add<u8>(x,static_cast<u8>(1)))))),span),span))));
+__jakt_var_295 = value; goto __jakt_label_280;
+
 }
+__jakt_label_280:; __jakt_var_295.release_value(); }));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_296; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_add<i8>(x,static_cast<i8>(1)))))),span),span))));
+__jakt_var_296 = value; goto __jakt_label_281;
 
 }
+__jakt_label_281:; __jakt_var_296.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_297; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_add<u16>(x,static_cast<u16>(1)))))),span),span))));
+__jakt_var_297 = value; goto __jakt_label_282;
+
 }
+__jakt_label_282:; __jakt_var_297.release_value(); }));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_298; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_add<i16>(x,static_cast<i16>(1)))))),span),span))));
+__jakt_var_298 = value; goto __jakt_label_283;
 
-return (TRY((((*this).call_prelude_function(((call).name),(TRY((DynamicArray<types::ResolvedNamespace>::create_with({})))),JaktInternal::OptionalNone(),arguments,span,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))))));
 }
-NonnullRefPtr<types::CheckedFunction> const function_to_run = ((((*this).program))->get_function((((call).function_id).value())));
-if (((((function_to_run)->type)).index() == 6 /* Closure */)){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot call a closure (nyi)"sv)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+__jakt_label_283:; __jakt_var_298.release_value(); }));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_299; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_add<u32>(x,static_cast<u32>(1)))))),span),span))));
+__jakt_var_299 = value; goto __jakt_label_284;
+
 }
-JaktInternal::Optional<types::Value> this_argument = JaktInternal::OptionalNone();
-JaktInternal::DynamicArray<types::Value> arguments = (TRY((DynamicArray<types::Value>::create_with({}))));
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+__jakt_label_284:; __jakt_var_299.release_value(); }));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_300; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_add<i32>(x,static_cast<i32>(1)))))),span),span))));
+__jakt_var_300 = value; goto __jakt_label_285;
+
 }
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
-{
-TRY((((arguments).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(((arg).template get<1>()),scope))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+__jakt_label_285:; __jakt_var_300.release_value(); }));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_301; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(x,static_cast<u64>(1ULL)))))),span),span))));
+__jakt_var_301 = value; goto __jakt_label_286;
+
 }
+__jakt_label_286:; __jakt_var_301.release_value(); }));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_302; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_add<i64>(x,static_cast<i64>(1LL)))))),span),span))));
+__jakt_var_302 = value; goto __jakt_label_287;
+
 }
+__jakt_label_287:; __jakt_var_302.release_value(); }));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_303; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((JaktInternal::checked_add<char>(x,static_cast<char>(1)))))),span),span))));
+__jakt_var_303 = value; goto __jakt_label_288;
+
+}
+__jakt_label_288:; __jakt_var_303.release_value(); }));
 };/*case end*/
-case 3: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
+int const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_304; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((JaktInternal::checked_add<int>(x,static_cast<size_t>(1ULL)))))),span),span))));
+__jakt_var_304 = value; goto __jakt_label_289;
+
 }
+__jakt_label_289:; __jakt_var_304.release_value(); }));
 };/*case end*/
-case 4: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_305; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(x,static_cast<size_t>(1ULL)))))),span),span))));
+__jakt_var_305 = value; goto __jakt_label_290;
+
 }
+__jakt_label_290:; __jakt_var_305.release_value(); }));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
+default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
-))))));
-}
+))) } );
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_306; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_add<u8>(x,static_cast<u8>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_306 = value; goto __jakt_label_291;
 
 }
-}
+__jakt_label_291:; __jakt_var_306.release_value(); }));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_307; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_add<i8>(x,static_cast<i8>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_307 = value; goto __jakt_label_292;
 
-JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings = (TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({}))));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((((function_to_run)->generics))->params)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-types::FunctionGenericParameter const param = ((((((function_to_run)->generics))->params))[i]);
-TRY((((type_bindings).set(TRY((((((param).type_id())).to_string()))),((((call).type_args))[i])))));
 }
+__jakt_label_292:; __jakt_var_307.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_308; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_add<u16>(x,static_cast<u16>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_308 = value; goto __jakt_label_293;
 
 }
-}
-
-JaktInternal::Dictionary<DeprecatedString,types::Value> const empty_bindings = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
-__jakt_var_341 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute((((call).function_id).value()),static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>>>(((call).namespace_)),this_argument,arguments,span,TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),JaktInternal::OptionalNone(),type_bindings)))))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+__jakt_label_293:; __jakt_var_308.release_value(); }));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)); goto __jakt_label_329;
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_309; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_add<i16>(x,static_cast<i16>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_309 = value; goto __jakt_label_294;
 
 }
-__jakt_label_329:; __jakt_var_341.release_value(); }));
+__jakt_label_294:; __jakt_var_309.release_value(); }));
 };/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedCall const& call = __jakt_match_value.call;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_342; {
-types::Value const this_argument = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_310; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_add<u32>(x,static_cast<u32>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_310 = value; goto __jakt_label_295;
+
 }
+__jakt_label_295:; __jakt_var_310.release_value(); }));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_311; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_add<i32>(x,static_cast<i32>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_311 = value; goto __jakt_label_296;
+
 }
+__jakt_label_296:; __jakt_var_311.release_value(); }));
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
-};/*case end*/
-case 3: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_312; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_add<u64>(x,static_cast<u64>(1ULL)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_312 = value; goto __jakt_label_297;
+
 }
+__jakt_label_297:; __jakt_var_312.release_value(); }));
 };/*case end*/
-case 4: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_313; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_add<i64>(x,static_cast<i64>(1LL)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_313 = value; goto __jakt_label_298;
+
 }
+__jakt_label_298:; __jakt_var_313.release_value(); }));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_314; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((JaktInternal::checked_add<char>(x,static_cast<char>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_314 = value; goto __jakt_label_299;
+
 }
+__jakt_label_299:; __jakt_var_314.release_value(); }));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<types::ResolvedNamespace> effective_namespace = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((this_argument).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("String"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
+int const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_315; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((JaktInternal::checked_add<int>(x,static_cast<size_t>(1ULL)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_315 = value; goto __jakt_label_300;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_300:; __jakt_var_315.release_value(); }));
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();types::TypeId const& type_id = __jakt_match_value.type_id;
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(args);
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_316; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_add<size_t>(x,static_cast<size_t>(1ULL)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_316 = value; goto __jakt_label_301;
+
+}
+__jakt_label_301:; __jakt_var_316.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic array"sv),((this_argument).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Array"sv),JaktInternal::OptionalNone(),generic_parameters)))));
-}
-return JaktInternal::ExplicitValue<void>();
+))) } );
 };/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();types::TypeId const& type_id = __jakt_match_value.type_id;
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+case 3: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
 switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(args);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_317; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_sub<u8>(x,static_cast<u8>(1)))))),span),span))));
+__jakt_var_317 = value; goto __jakt_label_302;
+
+}
+__jakt_label_302:; __jakt_var_317.release_value(); }));
 };/*case end*/
-default: {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic dictionary"sv),((this_argument).span)))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_318; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_sub<i8>(x,static_cast<i8>(1)))))),span),span))));
+__jakt_var_318 = value; goto __jakt_label_303;
+
 }
+__jakt_label_303:; __jakt_var_318.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Dictionary"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_319; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_sub<u16>(x,static_cast<u16>(1)))))),span),span))));
+__jakt_var_319 = value; goto __jakt_label_304;
+
+}
+__jakt_label_304:; __jakt_var_319.release_value(); }));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_320; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_sub<i16>(x,static_cast<i16>(1)))))),span),span))));
+__jakt_var_320 = value; goto __jakt_label_305;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_305:; __jakt_var_320.release_value(); }));
 };/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();types::TypeId const& type_id = __jakt_match_value.type_id;
-{
-if (((((((*this).program))->get_type(type_id)))->index() == 19 /* GenericInstance */)){
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = ((((((*this).program))->get_type(type_id)))->get<types::Type::GenericInstance>()).args;
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Set"sv),JaktInternal::OptionalNone(),generic_parameters)))));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic set"sv),((this_argument).span)))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_321; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_sub<u32>(x,static_cast<u32>(1)))))),span),span))));
+__jakt_var_321 = value; goto __jakt_label_306;
+
 }
+__jakt_label_306:; __jakt_var_321.release_value(); }));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_322; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_sub<i32>(x,static_cast<i32>(1)))))),span),span))));
+__jakt_var_322 = value; goto __jakt_label_307;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_307:; __jakt_var_322.release_value(); }));
 };/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();types::StructId const& struct_id = __jakt_match_value.struct_id;
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_struct(struct_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_323; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_sub<u64>(x,static_cast<u64>(1ULL)))))),span),span))));
+__jakt_var_323 = value; goto __jakt_label_308;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_308:; __jakt_var_323.release_value(); }));
 };/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Class>();types::StructId const& struct_id = __jakt_match_value.struct_id;
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_struct(struct_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_324; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_sub<i64>(x,static_cast<i64>(1LL)))))),span),span))));
+__jakt_var_324 = value; goto __jakt_label_309;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_309:; __jakt_var_324.release_value(); }));
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_enum(enum_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_325; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((JaktInternal::checked_sub<char>(x,static_cast<char>(1)))))),span),span))));
+__jakt_var_325 = value; goto __jakt_label_310;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_310:; __jakt_var_325.release_value(); }));
 };/*case end*/
-case 25: {
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Optional"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
+int const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_326; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((JaktInternal::checked_sub<int>(x,static_cast<size_t>(1ULL)))))),span),span))));
+__jakt_var_326 = value; goto __jakt_label_311;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_311:; __jakt_var_326.release_value(); }));
 };/*case end*/
-case 24: {
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Optional"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_327; {
+TRY((((*this).update_binding(expr,scope,types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_sub<size_t>(x,static_cast<size_t>(1ULL)))))),span),span))));
+__jakt_var_327 = value; goto __jakt_label_312;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_312:; __jakt_var_327.release_value(); }));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to call an instance method on a non-struct/enum type"sv),((this_argument).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-));
-if ((!(((((call).function_id)).has_value())))){
-JaktInternal::DynamicArray<types::Value> arguments = (TRY((DynamicArray<types::Value>::create_with({}))));
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
-{
-TRY((((arguments).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(((arg).template get<1>()),scope))));
+))) } );
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_328; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>((JaktInternal::checked_sub<u8>(x,static_cast<u8>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_328 = value; goto __jakt_label_313;
+
 }
+__jakt_label_313:; __jakt_var_328.release_value(); }));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_329; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>((JaktInternal::checked_sub<i8>(x,static_cast<i8>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_329 = value; goto __jakt_label_314;
+
 }
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+__jakt_label_314:; __jakt_var_329.release_value(); }));
 };/*case end*/
 case 3: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_330; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((JaktInternal::checked_sub<u16>(x,static_cast<u16>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_330 = value; goto __jakt_label_315;
+
+}
+__jakt_label_315:; __jakt_var_330.release_value(); }));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_331; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((JaktInternal::checked_sub<i16>(x,static_cast<i16>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_331 = value; goto __jakt_label_316;
+
 }
+__jakt_label_316:; __jakt_var_331.release_value(); }));
 };/*case end*/
 case 4: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_332; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((JaktInternal::checked_sub<u32>(x,static_cast<u32>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_332 = value; goto __jakt_label_317;
+
 }
+__jakt_label_317:; __jakt_var_332.release_value(); }));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_333; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((JaktInternal::checked_sub<i32>(x,static_cast<i32>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_333 = value; goto __jakt_label_318;
+
 }
+__jakt_label_318:; __jakt_var_333.release_value(); }));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-))))));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_334; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((JaktInternal::checked_sub<u64>(x,static_cast<u64>(1ULL)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_334 = value; goto __jakt_label_319;
+
 }
+__jakt_label_319:; __jakt_var_334.release_value(); }));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_335; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((JaktInternal::checked_sub<i64>(x,static_cast<i64>(1LL)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_335 = value; goto __jakt_label_320;
 
 }
+__jakt_label_320:; __jakt_var_335.release_value(); }));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CChar>();
+char const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_336; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((JaktInternal::checked_sub<char>(x,static_cast<char>(1)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_336 = value; goto __jakt_label_321;
+
 }
+__jakt_label_321:; __jakt_var_336.release_value(); }));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::CInt>();
+int const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_337; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((JaktInternal::checked_sub<int>(x,static_cast<size_t>(1ULL)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_337 = value; goto __jakt_label_322;
 
-return (TRY((((*this).call_prelude_function(((call).name),effective_namespace,this_argument,arguments,span,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))))));
 }
-NonnullRefPtr<types::CheckedFunction> const function_to_run = ((((*this).program))->get_function((((call).function_id).value())));
-JaktInternal::DynamicArray<types::Value> arguments = (TRY((DynamicArray<types::Value>::create_with({}))));
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+__jakt_label_322:; __jakt_var_337.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::Value> __jakt_var_338; {
+types::Value const value = types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((JaktInternal::checked_sub<size_t>(x,static_cast<size_t>(1ULL)))))),span);
+TRY((((*this).update_binding(expr,scope,value,span))));
+__jakt_var_338 = value; goto __jakt_label_323;
+
 }
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
-{
-TRY((((arguments).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(((arg).template get<1>()),scope))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
+__jakt_label_323:; __jakt_var_338.release_value(); }));
+};/*case end*/
+default: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type for unary operator"sv)))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
+}/*switch end*/
+}()
+))) } );
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::TypeCast>();
+types::CheckedTypeCast const& cast = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = cast;
+switch(__jakt_match_variant.index()) {
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Infallible>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((interpreter::cast_value_to_type(value,type_id,*this,false)))) } );
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Fallible>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_339; {
+__jakt_var_339 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(TRY((interpreter::cast_value_to_type(value,type_id,*this,false)))))),span)) } ; goto __jakt_label_324;
+
 }
+__jakt_label_324:; __jakt_var_339.release_value(); }));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 };/*case end*/
-case 3: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedUnaryOperator::IsEnumVariant>();types::CheckedEnumVariant const& enum_variant = __jakt_match_value.enum_variant;
+JaktInternal::DynamicArray<types::CheckedEnumVariantBinding> const& bindings = __jakt_match_value.bindings;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::FunctionId const& constructor = __jakt_match_value.constructor;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_340; {
+DeprecatedString const constructor_name = ((((((*this).program))->get_function(constructor)))->name);
+if ((((enum_variant).name()) != constructor_name)){
+return ( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(false))),span)) } );
 }
-};/*case end*/
-case 4: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+__jakt_var_340 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(true))),span)) } ; goto __jakt_label_325;
+
 }
+__jakt_label_325:; __jakt_var_340.release_value(); }));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
+default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid value for unary operator '{}'"sv),op))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
-))))));
-}
-
-}
-}
-
-__jakt_var_342 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute((((call).function_id).value()),static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>>>(((call).namespace_)),this_argument,arguments,span,JaktInternal::OptionalNone()))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+)));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unimplemented unary operator '{}'"sv),op))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
-)); goto __jakt_label_330;
+)); goto __jakt_label_279;
 
 }
-__jakt_label_330:; __jakt_var_342.release_value(); }));
+__jakt_label_279:; __jakt_var_294.release_value(); }));
 };/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalNone>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),span)) } );
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalSome>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& from = __jakt_match_value.from;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& to = __jakt_match_value.to;
 utility::Span const& span = __jakt_match_value.span;
-{
-interpreter::StatementResult const result = TRY((((*this).execute_expression(expr,scope))));
-if (((result).index() == 5 /* JustValue */)){
-types::Value const value = ((result).get<interpreter::StatementResult::JustValue>()).value;
-return ( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(value))),span)) } );
-}
-return (result);
-}
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_343; {
-types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_341; {
+types::Value const start = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((from).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression((from.value()),scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -14220,52 +14481,21 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-));
-if (((((value).impl))->index() == 25 /* OptionalNone */)){
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to unwrap an optional value that was None"sv),((value).span)))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+)));
 }
-__jakt_var_343 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
-};/*case end*/
-default: {
+else {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid type for unwrap"sv),((value).span)))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(Jakt::DeprecatedString("Partial ranges are not implemented"sv),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_331;
-
 }
-__jakt_label_331:; __jakt_var_343.release_value(); }));
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).execute_block(block,scope,span)))));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ByteConstant>();DeprecatedString const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((val).byte_at(static_cast<size_t>(0ULL)))))),span)) } );
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((((scope)->must_get(((var)->name)))))) } );
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-NonnullRefPtr<typename types::CheckedExpression> const& index_expr = __jakt_match_value.index;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_344; {
-types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
+}()))
+;
+types::Value const end = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((to).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression((to.value()),scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -14305,9 +14535,40 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-));
-types::Value const index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(index_expr,scope))));
+)));
+}
+else {
+{
+TRY((((*this).error(Jakt::DeprecatedString("Partial ranges are not implemented"sv),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+}
+}()))
+;
+types::StructId const range_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Range"sv)))));
+JaktInternal::DynamicArray<types::FunctionId> const range_constructors = (TRY((((((*this).program))->find_functions_with_name_in_scope(((((((*this).program))->get_struct(range_struct_id))).scope_id),Jakt::DeprecatedString("Range"sv))))).value());
+__jakt_var_341 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>((TRY((DynamicArray<types::Value>::create_with({start, end})))),range_struct_id,((range_constructors)[static_cast<i64>(0LL)])))),span)) } ; goto __jakt_label_326;
+
+}
+__jakt_label_326:; __jakt_var_341.release_value(); }));
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_342; {
+if ((!(((((call).function_id)).has_value())))){
+JaktInternal::DynamicArray<types::Value> arguments = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
+{
+TRY((((arguments).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(((arg).template get<1>()),scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -14325,124 +14586,54 @@ return ( interpreter::StatementResult { typename interpreter::StatementResult::T
 };/*case end*/
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
-};/*case end*/
-case 3: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
-}
-};/*case end*/
-case 4: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
-}
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
-}
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-__jakt_var_344 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_345; {
-u64 const numeric_index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((index).impl);
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
-default: {
+case 3: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid type for repeat"sv));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
 };/*case end*/
-}/*switch end*/
-}()
-));
-if ((numeric_index >= (infallible_integer_cast<u64>((((values).size())))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index {} out of bounds (max={})"sv),numeric_index,((values).size())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-__jakt_var_345 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((values)[numeric_index])) } ; goto __jakt_label_333;
-
+case 4: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-__jakt_label_333:; __jakt_var_345.release_value(); }));
 };/*case end*/
-default: {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid or unsupported indexed expression"sv),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)); goto __jakt_label_332;
+))))));
+}
 
 }
-__jakt_label_332:; __jakt_var_344.release_value(); }));
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();bool const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(val))),span)) } );
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-DeprecatedString const& index = __jakt_match_value.index;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_346; {
-types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
+}
+
+return (TRY((((*this).call_prelude_function(((call).name),(TRY((DynamicArray<types::ResolvedNamespace>::create_with({})))),JaktInternal::OptionalNone(),arguments,span,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))))));
+}
+NonnullRefPtr<types::CheckedFunction> const function_to_run = ((((*this).program))->get_function((((call).function_id).value())));
+if (((((function_to_run)->type)).index() == 6 /* Closure */)){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot call a closure (nyi)"sv)))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+JaktInternal::Optional<types::Value> this_argument = JaktInternal::OptionalNone();
+JaktInternal::DynamicArray<types::Value> arguments = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
+{
+TRY((((arguments).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(((arg).template get<1>()),scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -14482,98 +14673,56 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-));
-__jakt_var_346 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::StructId const& struct_id = __jakt_match_value.struct_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_347; {
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-i64 idx = static_cast<i64>(0LL);
-JaktInternal::Optional<i64> found_index = JaktInternal::OptionalNone();
-{
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedField field = (_magic_value.value());
-{
-if ((((((((*this).program))->get_variable(((field).variable_id))))->name) == index)){
-(found_index = idx);
-break;
-}
-({auto& _jakt_ref = idx;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
+))))));
 }
 
 }
 }
 
-if ((!(((found_index).has_value())))){
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field that does not exist"sv),((value).span)))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-__jakt_var_347 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[(found_index.value())])) } ; goto __jakt_label_335;
-
-}
-__jakt_label_335:; __jakt_var_347.release_value(); }));
-};/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Class>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::StructId const& struct_id = __jakt_match_value.struct_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_348; {
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-i64 idx = static_cast<i64>(0LL);
-JaktInternal::Optional<i64> found_index = JaktInternal::OptionalNone();
+JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings = (TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((((function_to_run)->generics))->params)).size()))});
 for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedField field = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-if ((((((((*this).program))->get_variable(((field).variable_id))))->name) == index)){
-(found_index = idx);
-break;
-}
-({auto& _jakt_ref = idx;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
+types::FunctionGenericParameter const param = ((((((function_to_run)->generics))->params))[i]);
+TRY((((type_bindings).set(TRY((((((param).type_id())).to_string()))),((((call).type_args))[i])))));
 }
 
 }
 }
 
-if ((!(((found_index).has_value())))){
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field that does not exist"sv),((value).span)))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-__jakt_var_348 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[(found_index.value())])) } ; goto __jakt_label_336;
-
-}
-__jakt_label_336:; __jakt_var_348.release_value(); }));
+JaktInternal::Dictionary<DeprecatedString,types::Value> const empty_bindings = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
+__jakt_var_342 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute((((call).function_id).value()),static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>>>(((call).namespace_)),this_argument,arguments,span,TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),JaktInternal::OptionalNone(),type_bindings)))))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
 };/*case end*/
-default: {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field on a non-struct/enum type"sv),((value).span)))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)); goto __jakt_label_334;
+)); goto __jakt_label_327;
 
 }
-__jakt_label_334:; __jakt_var_346.release_value(); }));
+__jakt_label_327:; __jakt_var_342.release_value(); }));
 };/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-DeprecatedString const& index = __jakt_match_value.index;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_349; {
-types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedCall const& call = __jakt_match_value.call;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_343; {
+types::Value const this_argument = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
@@ -14615,121 +14764,139 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-__jakt_var_349 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
+JaktInternal::DynamicArray<types::ResolvedNamespace> effective_namespace = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((this_argument).impl);
 switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::EnumId const& enum_id = __jakt_match_value.enum_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_350; {
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-i64 idx = static_cast<i64>(0LL);
-JaktInternal::Optional<i64> found_index = JaktInternal::OptionalNone();
+case 13: {
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("String"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
-types::CheckedField field = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();types::TypeId const& type_id = __jakt_match_value.type_id;
 {
-if ((((((((*this).program))->get_variable(((field).variable_id))))->name) == index)){
-(found_index = idx);
-break;
-}
-({auto& _jakt_ref = idx;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
-}
-
-}
-}
-
-if ((!(((found_index).has_value())))){
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field that does not exist"sv),((value).span)))));
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(args);
+};/*case end*/
+default: {
+{
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic array"sv),((this_argument).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_var_350 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[(found_index.value())])) } ; goto __jakt_label_338;
-
+};/*case end*/
+}/*switch end*/
+}()
+));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Array"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
-__jakt_label_338:; __jakt_var_350.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();types::TypeId const& type_id = __jakt_match_value.type_id;
+{
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(args);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field on a non-struct/enum type"sv),((value).span)))));
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic dictionary"sv),((this_argument).span)))));
 return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)); goto __jakt_label_337;
-
+));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Dictionary"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
-__jakt_label_337:; __jakt_var_349.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_351; {
-JaktInternal::DynamicArray<types::Value> keys = (TRY((DynamicArray<types::Value>::create_with({}))));
-JaktInternal::DynamicArray<types::Value> values = (TRY((DynamicArray<types::Value>::create_with({}))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();types::TypeId const& type_id = __jakt_match_value.type_id;
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((((((*this).program))->get_type(type_id)))->index() == 19 /* GenericInstance */)){
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = ((((((*this).program))->get_type(type_id)))->get<types::Type::GenericInstance>()).args;
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Set"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic set"sv),((this_argument).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> k__v__ = (_magic_value.value());
-{
-JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> const jakt__k__v__ = k__v__;
-NonnullRefPtr<typename types::CheckedExpression> const k = ((jakt__k__v__).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const v = ((jakt__k__v__).template get<1>());
 
-types::Value const key = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(k,scope))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();types::StructId const& struct_id = __jakt_match_value.struct_id;
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_struct(struct_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Class>();types::StructId const& struct_id = __jakt_match_value.struct_id;
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_struct(struct_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
+{
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_enum(enum_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
+case 25: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Optional"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
+case 24: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Optional"sv),JaktInternal::OptionalNone(),generic_parameters)))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& expr = __jakt_match_value.value;
+default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to call an instance method on a non-struct/enum type"sv),((this_argument).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 ));
-types::Value const val = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(v,scope))));
+if ((!(((((call).function_id)).has_value())))){
+JaktInternal::DynamicArray<types::Value> arguments = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
+{
+TRY((((arguments).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(((arg).template get<1>()),scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -14769,215 +14936,27 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-));
-TRY((((keys).push(key))));
-TRY((((values).push(val))));
-}
-
-}
-}
-
-__jakt_var_351 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktDictionary>(keys,values,type_id))),span)) } ; goto __jakt_label_339;
-
-}
-__jakt_label_339:; __jakt_var_351.release_value(); }));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NumericConstant>();types::CheckedNumericConstant const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = val;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>(x))),span));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>(x))),span));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(x))),span));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>(x))),span));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(x))),span));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>(x))),span));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(x))),span));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(x))),span));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::USize>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((x)))))),span));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F32>();
-f32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>(x))),span));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F64>();
-f64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>(x))),span));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-))) } );
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::QuotedString>();types::CheckedStringLiteral const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((((val).type_id)).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ))));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((utility::interpret_escapes(((val).to_string()))))))),span)) } );
-}
-else {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_352; {
-types::FunctionId const function_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::FunctionId, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(((val).type_id)));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::FunctionId> __jakt_var_353; {
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((((((*this).program))->get_struct(struct_id))).scope_id)))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const overloads = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
-if ((!(((overloads).has_value())))){
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Failed to find a from_string_literal overload in {}"sv),TRY((((((*this).program))->type_name(((val).type_id),false))))))));
-}
-__jakt_var_353 = ((((overloads.value())).first()).value()); goto __jakt_label_341;
-
-}
-__jakt_label_341:; __jakt_var_353.release_value(); }));
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue(({ Optional<types::FunctionId> __jakt_var_354; {
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((((((*this).program))->get_struct(struct_id))).scope_id)))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const overloads = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
-if ((!(((overloads).has_value())))){
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Failed to find a from_string_literal overload in {}"sv),TRY((((((*this).program))->type_name(((val).type_id),false))))))));
-}
-__jakt_var_354 = ((((overloads.value())).first()).value()); goto __jakt_label_342;
-
-}
-__jakt_label_342:; __jakt_var_354.release_value(); }));
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::FunctionId> __jakt_var_355; {
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((((((*this).program))->get_enum(enum_id))).scope_id)))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const overloads = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
-if ((!(((overloads).has_value())))){
-utility::panic(Jakt::DeprecatedString("Failed to find a from_string_literal overload"sv));
+))))));
 }
-__jakt_var_355 = ((((overloads.value())).first()).value()); goto __jakt_label_343;
 
 }
-__jakt_label_343:; __jakt_var_355.release_value(); }));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue(({ Optional<types::FunctionId> __jakt_var_356; {
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((((((*this).program))->get_enum(enum_id))).scope_id)))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const overloads = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
-if ((!(((overloads).has_value())))){
-utility::panic(Jakt::DeprecatedString("Failed to find a from_string_literal overload"sv));
 }
-__jakt_var_356 = ((((overloads.value())).first()).value()); goto __jakt_label_344;
 
+return (TRY((((*this).call_prelude_function(((call).name),effective_namespace,this_argument,arguments,span,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))))));
 }
-__jakt_label_344:; __jakt_var_356.release_value(); }));
-};/*case end*/
-default: {
+NonnullRefPtr<types::CheckedFunction> const function_to_run = ((((*this).program))->get_function((((call).function_id).value())));
+JaktInternal::DynamicArray<types::Value> arguments = (TRY((DynamicArray<types::Value>::create_with({}))));
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type {} for string literal"sv),((((*this).program))->get_type(((val).type_id)))))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<types::ResolvedNamespace> const ns = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
-__jakt_var_352 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute(function_id,static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>>>(ns),JaktInternal::OptionalNone(),(TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((utility::interpret_escapes(((val).to_string()))))))),span)})))),span,scope))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)); goto __jakt_label_340;
-
-}
-__jakt_label_340:; __jakt_var_352.release_value(); }));
-}
-}()))
-);
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CCharacterConstant>();DeprecatedString const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((infallible_integer_cast<char>((((val).byte_at(static_cast<size_t>(0ULL))))))))),span)) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CharacterConstant>();DeprecatedString const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_357; {
-DeprecatedStringCodePointIterator code_points = ((val).code_points());
-JaktInternal::Optional<u32> const code_point = ((code_points).next());
-if ((!(((code_point).has_value())))){
-TRY((((*this).error(Jakt::DeprecatedString("Invalid character constant"sv),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidCharacterConstant))));
-}
-__jakt_var_357 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((code_point.value())))),span)) } ; goto __jakt_label_345;
-
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_345:; __jakt_var_357.release_value(); }));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& repeat = __jakt_match_value.repeat;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((repeat).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_358; {
-size_t const count = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression((repeat.value()),scope))));
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
+{
+TRY((((arguments).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(((arg).template get<1>()),scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -14996,62 +14975,7 @@ return ( interpreter::StatementResult { typename interpreter::StatementResult::T
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
 types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
-};/*case end*/
-default: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid type for repeat"sv));
-}
-};/*case end*/
-}/*switch end*/
-}()
-)));
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 case 3: {
 {
@@ -15072,9 +14996,53 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-));
-types::Value const value_to_repeat = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(((vals)[static_cast<i64>(0LL)]),scope))));
+))))));
+}
+
+}
+}
+
+__jakt_var_343 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute((((call).function_id).value()),static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>>>(((call).namespace_)),this_argument,arguments,span,JaktInternal::OptionalNone()))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_328;
+
+}
+__jakt_label_328:; __jakt_var_343.release_value(); }));
+};/*case end*/
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalNone>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalNone>())),span)) } );
+};/*case end*/
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalSome>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+{
+interpreter::StatementResult const result = TRY((((*this).execute_expression(expr,scope))));
+if (((result).index() == 5 /* JustValue */)){
+types::Value const value = ((result).get<interpreter::StatementResult::JustValue>()).value;
+return ( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(value))),span)) } );
+}
+return (result);
+}
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_344; {
+types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -15115,25 +15083,51 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-__jakt_var_358 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>((TRY((DynamicArray<types::Value>::filled(count, value_to_repeat)))),TRY((((((*this).program))->substitute_typevars_in_type(type_id,TRY((((scope)->type_map_for_substitution()))),((type_id).module)))))))),span)) } ; goto __jakt_label_346;
-
-}
-__jakt_label_346:; __jakt_var_358.release_value(); }));
+if (((((value).impl))->index() == 25 /* OptionalNone */)){
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to unwrap an optional value that was None"sv),((value).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-else {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_359; {
-JaktInternal::DynamicArray<types::Value> values = (TRY((DynamicArray<types::Value>::create_with({}))));
+__jakt_var_344 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::OptionalSome>();types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+};/*case end*/
+default: {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Invalid type for unwrap"sv),((value).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-NonnullRefPtr<typename types::CheckedExpression> value = (_magic_value.value());
-{
-types::Value const val = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(value,scope))));
+};/*case end*/
+}/*switch end*/
+}()
+)); goto __jakt_label_329;
+
+}
+__jakt_label_329:; __jakt_var_344.release_value(); }));
+};/*case end*/
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).execute_block(block,scope,span)))));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ByteConstant>();DeprecatedString const& val = __jakt_match_value.val;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(((val).byte_at(static_cast<size_t>(0ULL)))))),span)) } );
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((((scope)->must_get(((var)->name)))))) } );
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+NonnullRefPtr<typename types::CheckedExpression> const& index_expr = __jakt_match_value.index;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_345; {
+types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -15174,32 +15168,9 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-TRY((((values).push(val))));
-}
-
-}
-}
-
-__jakt_var_359 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(values,TRY((((((*this).program))->substitute_typevars_in_type(type_id,TRY((((scope)->type_map_for_substitution()))),((type_id).module)))))))),span)) } ; goto __jakt_label_347;
-
-}
-__jakt_label_347:; __jakt_var_359.release_value(); }));
-}
-}()))
-);
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-size_t const& index = __jakt_match_value.index;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_360; {
-types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
+types::Value const index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(index_expr,scope))));
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
-};/*case end*/
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
@@ -15214,6 +15185,11 @@ types::Value const& value = __jakt_match_value.value;
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 };/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
@@ -15225,6 +15201,8 @@ return ( interpreter::StatementResult { typename interpreter::StatementResult::B
 }
 };/*case end*/
 case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
@@ -15232,41 +15210,102 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-__jakt_var_360 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((((value).impl))->index() == 26 /* JaktTuple */));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_361; {
-JaktInternal::DynamicArray<types::Value> const fields = ((((value).impl))->get<types::ValueImpl::JaktTuple>()).fields;
-__jakt_var_361 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[index])) } ; goto __jakt_label_349;
-
+__jakt_var_345 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_346; {
+u64 const numeric_index = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((index).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>((x))));
+};/*case end*/
+default: {
+{
+utility::panic(Jakt::DeprecatedString("Invalid type for repeat"sv));
+}
+};/*case end*/
+}/*switch end*/
+}()
+));
+if ((numeric_index >= (infallible_integer_cast<u64>((((values).size())))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index {} out of bounds (max={})"sv),numeric_index,((values).size())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-__jakt_label_349:; __jakt_var_361.release_value(); }));
+__jakt_var_346 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((values)[numeric_index])) } ; goto __jakt_label_331;
+
 }
-else {
+__jakt_label_331:; __jakt_var_346.release_value(); }));
+};/*case end*/
+default: {
 {
-utility::panic(Jakt::DeprecatedString("expected tuple"sv));
-}
+TRY((((*this).error(Jakt::DeprecatedString("Invalid or unsupported indexed expression"sv),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-}()))
-; goto __jakt_label_348;
+};/*case end*/
+}/*switch end*/
+}()
+)); goto __jakt_label_330;
 
 }
-__jakt_label_348:; __jakt_var_360.release_value(); }));
+__jakt_label_330:; __jakt_var_345.release_value(); }));
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Match>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-JaktInternal::DynamicArray<types::CheckedMatchCase> const& match_cases = __jakt_match_value.match_cases;
-bool const& all_variants_constant = __jakt_match_value.all_variants_constant;
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();bool const& val = __jakt_match_value.val;
 utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_362; {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Bool>(val))),span)) } );
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+DeprecatedString const& index = __jakt_match_value.index;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_347; {
 types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
-};/*case end*/
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
@@ -15281,6 +15320,11 @@ types::Value const& value = __jakt_match_value.value;
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 };/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
@@ -15292,6 +15336,8 @@ return ( interpreter::StatementResult { typename interpreter::StatementResult::B
 }
 };/*case end*/
 case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
@@ -15299,254 +15345,211 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-__jakt_var_362 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+__jakt_var_347 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
 auto&& __jakt_match_variant = *((value).impl);
 switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::EnumId const& enum_id = __jakt_match_value.enum_id;
-types::FunctionId const& constructor = __jakt_match_value.constructor;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_363; {
-DeprecatedString const constructor_name = ((((((*this).program))->get_function(constructor)))->name);
-JaktInternal::Optional<types::CheckedMatchBody> catch_all_case = JaktInternal::OptionalNone();
-JaktInternal::Optional<types::CheckedMatchBody> found_body = JaktInternal::OptionalNone();
-JaktInternal::Optional<JaktInternal::DynamicArray<parser::EnumVariantPatternArgument>> found_args = JaktInternal::OptionalNone();
-JaktInternal::Optional<size_t> found_variant_index = JaktInternal::OptionalNone();
-JaktInternal::Optional<utility::Span> span = JaktInternal::OptionalNone();
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::StructId const& struct_id = __jakt_match_value.struct_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_348; {
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+i64 idx = static_cast<i64>(0LL);
+JaktInternal::Optional<i64> found_index = JaktInternal::OptionalNone();
 {
-JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedMatchCase> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedMatchCase match_case = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = match_case;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::EnumVariant>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& args = __jakt_match_value.args;
-size_t const& index = __jakt_match_value.index;
-types::CheckedMatchBody const& body = __jakt_match_value.body;
-utility::Span const& marker_span = __jakt_match_value.marker_span;
-{
-if ((name != constructor_name)){
-return JaktInternal::LoopContinue{};
-}
-(found_body = body);
-(found_args = args);
-(found_variant_index = index);
-(span = marker_span);
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::Expression>();utility::Span const& marker_span = __jakt_match_value.marker_span;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Value matches are not allowed on enums"sv),marker_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
-utility::Span const& marker_span = __jakt_match_value.marker_span;
+types::CheckedField field = (_magic_value.value());
 {
-(catch_all_case = body);
-(span = marker_span);
-return JaktInternal::LoopContinue{};
+if ((((((((*this).program))->get_variable(((field).variable_id))))->name) == index)){
+(found_index = idx);
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
+({auto& _jakt_ref = idx;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
 }
 
 }
 }
 
-(found_body = found_body.value_or_lazy_evaluated([&] { return (catch_all_case.value()); }));
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const empty_args = (TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({}))));
-(found_args = found_args.value_or_lazy_evaluated([&] { return empty_args; }));
-NonnullRefPtr<interpreter::InterpreterScope> new_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
-ScopeGuard __jakt_var_364([&] {
-MUST((((new_scope)->perform_defers(*this,(span.value())))));
-});
-if ((((found_variant_index).has_value()) && (!((((found_args.value())).is_empty()))))){
-types::CheckedEnumVariant const variant = ((((((((*this).program))->get_enum(enum_id))).variants))[(found_variant_index.value())]);
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 0: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-{
+if ((!(((found_index).has_value())))){
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field that does not exist"sv),((value).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-{
-TRY((((((new_scope)->bindings)).set((((((found_args.value()))[static_cast<i64>(0LL)])).binding),((fields)[static_cast<i64>(0LL)])))));
+__jakt_var_348 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[(found_index.value())])) } ; goto __jakt_label_333;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_333:; __jakt_var_348.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& variant_fields = __jakt_match_value.fields;
-{
-i64 i = static_cast<i64>(0LL);
-{
-JaktInternal::ArrayIterator<types::VarId> _magic = ((variant_fields).iterator());
-for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::VarId var_id = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const field = ((((*this).program))->get_variable(var_id));
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Class>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::StructId const& struct_id = __jakt_match_value.struct_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_349; {
+types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
+i64 idx = static_cast<i64>(0LL);
+JaktInternal::Optional<i64> found_index = JaktInternal::OptionalNone();
 {
-JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = (((found_args.value())).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
 for (;;){
-JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::EnumVariantPatternArgument arg = (_magic_value.value());
+types::CheckedField field = (_magic_value.value());
 {
-DeprecatedString const matched_name = ((arg).name).value_or_lazy_evaluated([&] { return ((arg).binding); });
-if ((matched_name == ((field)->name))){
-TRY((((((new_scope)->bindings)).set(((arg).binding),((fields)[i])))));
+if ((((((((*this).program))->get_variable(((field).variable_id))))->name) == index)){
+(found_index = idx);
 break;
 }
+({auto& _jakt_ref = idx;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
 }
 
 }
 }
 
-({auto& _jakt_ref = i;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
+if ((!(((found_index).has_value())))){
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field that does not exist"sv),((value).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
+__jakt_var_349 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[(found_index.value())])) } ; goto __jakt_label_334;
 
 }
+__jakt_label_334:; __jakt_var_349.release_value(); }));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field on a non-struct/enum type"sv),((value).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
-
-}
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
-));
+)); goto __jakt_label_332;
+
 }
-__jakt_var_363 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = (found_body.value());
+__jakt_label_332:; __jakt_var_347.release_value(); }));
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+DeprecatedString const& index = __jakt_match_value.index;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_350; {
+types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Expression>();
-NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_365; {
-interpreter::StatementResult const result = TRY((((*this).execute_expression(expr,new_scope))));
-__jakt_var_365 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = result;
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)); goto __jakt_label_352;
-
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-__jakt_label_352:; __jakt_var_365.release_value(); }));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Block>();
-types::CheckedBlock const& block = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_366; {
-interpreter::StatementResult const result = TRY((((*this).execute_block(block,new_scope,(span.value())))));
-__jakt_var_366 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = result;
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
 types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(result);
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+}
 };/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(result);
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(result);
+case 3: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+}
 };/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(result);
+case 4: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+}
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(result);
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+}
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)); goto __jakt_label_353;
+));
+__jakt_var_350 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::EnumId const& enum_id = __jakt_match_value.enum_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_351; {
+types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
+i64 idx = static_cast<i64>(0LL);
+JaktInternal::Optional<i64> found_index = JaktInternal::OptionalNone();
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedField field = (_magic_value.value());
+{
+if ((((((((*this).program))->get_variable(((field).variable_id))))->name) == index)){
+(found_index = idx);
+break;
+}
+({auto& _jakt_ref = idx;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
+}
+
+}
+}
+
+if ((!(((found_index).has_value())))){
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field that does not exist"sv),((value).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+__jakt_var_351 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[(found_index.value())])) } ; goto __jakt_label_336;
 
 }
-__jakt_label_353:; __jakt_var_366.release_value(); }));
+__jakt_label_336:; __jakt_var_351.release_value(); }));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+default: {
+{
+TRY((((*this).error(Jakt::DeprecatedString("Attempted to access a field on a non-struct/enum type"sv),((value).span)))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
 }()
-)); goto __jakt_label_351;
+)); goto __jakt_label_335;
 
 }
-__jakt_label_351:; __jakt_var_363.release_value(); }));
+__jakt_label_335:; __jakt_var_350.release_value(); }));
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_367; {
-JaktInternal::Optional<types::CheckedMatchBody> catch_all_case = JaktInternal::OptionalNone();
-JaktInternal::Optional<types::CheckedMatchBody> found_body = JaktInternal::OptionalNone();
-JaktInternal::Optional<utility::Span> span = JaktInternal::OptionalNone();
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_352; {
+JaktInternal::DynamicArray<types::Value> keys = (TRY((DynamicArray<types::Value>::create_with({}))));
+JaktInternal::DynamicArray<types::Value> values = (TRY((DynamicArray<types::Value>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
+JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedMatchCase> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedMatchCase match_case = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = match_case;
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::Expression>();types::CheckedMatchBody const& body = __jakt_match_value.body;
-NonnullRefPtr<typename types::CheckedExpression> const& expression = __jakt_match_value.expression;
-utility::Span const& marker_span = __jakt_match_value.marker_span;
+JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> k__v__ = (_magic_value.value());
 {
-types::Value const value_to_match_against = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expression,scope))));
+JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> const jakt__k__v__ = k__v__;
+NonnullRefPtr<typename types::CheckedExpression> const k = ((jakt__k__v__).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const v = ((jakt__k__v__).template get<1>());
+
+types::Value const key = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(k,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -15578,6 +15581,8 @@ return ( interpreter::StatementResult { typename interpreter::StatementResult::B
 }
 };/*case end*/
 case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
@@ -15585,146 +15590,257 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-if (((((value_to_match_against).impl))->equals(((value).impl)))){
-(found_body = static_cast<JaktInternal::Optional<types::CheckedMatchBody>>(body));
-(span = static_cast<JaktInternal::Optional<utility::Span>>(marker_span));
-return JaktInternal::LoopBreak{};
+types::Value const val = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(v,scope))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
-utility::Span const& marker_span = __jakt_match_value.marker_span;
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
+case 3: {
 {
-(catch_all_case = body);
-(span = marker_span);
-return JaktInternal::LoopContinue{};
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::EnumVariant>();utility::Span const& marker_span = __jakt_match_value.marker_span;
+case 4: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Value matches cannot have enum variant arms (matching on {})"sv),((value).type_name())))),marker_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+}
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
+TRY((((keys).push(key))));
+TRY((((values).push(val))));
 }
 
 }
 }
 
-(found_body = found_body.value_or_lazy_evaluated([&] { return (catch_all_case.value()); }));
-NonnullRefPtr<interpreter::InterpreterScope> new_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
-ScopeGuard __jakt_var_368([&] {
-MUST((((new_scope)->perform_defers(*this,(span.value())))));
-});
-__jakt_var_367 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = (found_body.value());
+__jakt_var_352 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktDictionary>(keys,values,type_id))),span)) } ; goto __jakt_label_337;
+
+}
+__jakt_label_337:; __jakt_var_352.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NumericConstant>();types::CheckedNumericConstant const& val = __jakt_match_value.val;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = val;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Expression>();
-NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_369; {
-interpreter::StatementResult const result = TRY((((*this).execute_expression(expr,new_scope))));
-__jakt_var_369 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = result;
-switch(__jakt_match_variant.index()) {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I8>(x))),span));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>(x))),span));
+};/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>(x))),span));
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(result);
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>(x))),span));
 };/*case end*/
 case 4: {
-return JaktInternal::ExplicitValue(result);
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U8>(x))),span));
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue(result);
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>(x))),span));
 };/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(result);
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>(x))),span));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>(x))),span));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::USize>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((x)))))),span));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F32>();
+f32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F32>(x))),span));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F64>();
+f64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::F64>(x))),span));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+))) } );
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::QuotedString>();types::CheckedStringLiteral const& val = __jakt_match_value.val;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((((val).type_id)).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ))));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((utility::interpret_escapes(((val).to_string()))))))),span)) } );
+}
+else {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_353; {
+types::FunctionId const function_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::FunctionId, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(((val).type_id)));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::FunctionId> __jakt_var_354; {
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((((((*this).program))->get_struct(struct_id))).scope_id)))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const overloads = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
+if ((!(((overloads).has_value())))){
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Failed to find a from_string_literal overload in {}"sv),TRY((((((*this).program))->type_name(((val).type_id),false))))))));
+}
+__jakt_var_354 = ((((overloads.value())).first()).value()); goto __jakt_label_339;
+
+}
+__jakt_label_339:; __jakt_var_354.release_value(); }));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue(({ Optional<types::FunctionId> __jakt_var_355; {
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((((((*this).program))->get_struct(struct_id))).scope_id)))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const overloads = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
+if ((!(((overloads).has_value())))){
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Failed to find a from_string_literal overload in {}"sv),TRY((((((*this).program))->type_name(((val).type_id),false))))))));
+}
+__jakt_var_355 = ((((overloads.value())).first()).value()); goto __jakt_label_340;
+
+}
+__jakt_label_340:; __jakt_var_355.release_value(); }));
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(result);
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::FunctionId> __jakt_var_356; {
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((((((*this).program))->get_enum(enum_id))).scope_id)))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const overloads = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
+if ((!(((overloads).has_value())))){
+utility::panic(Jakt::DeprecatedString("Failed to find a from_string_literal overload"sv));
+}
+__jakt_var_356 = ((((overloads.value())).first()).value()); goto __jakt_label_341;
+
+}
+__jakt_label_341:; __jakt_var_356.release_value(); }));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)); goto __jakt_label_355;
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue(({ Optional<types::FunctionId> __jakt_var_357; {
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope(((((((*this).program))->get_enum(enum_id))).scope_id)))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const overloads = ((((scope)->functions)).get(Jakt::DeprecatedString("from_string_literal"sv)));
+if ((!(((overloads).has_value())))){
+utility::panic(Jakt::DeprecatedString("Failed to find a from_string_literal overload"sv));
+}
+__jakt_var_357 = ((((overloads.value())).first()).value()); goto __jakt_label_342;
 
 }
-__jakt_label_355:; __jakt_var_369.release_value(); }));
+__jakt_label_342:; __jakt_var_357.release_value(); }));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Block>();
-types::CheckedBlock const& block = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_370; {
-interpreter::StatementResult const result = TRY((((*this).execute_block(block,new_scope,(span.value())))));
-__jakt_var_370 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = result;
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid type {} for string literal"sv),((((*this).program))->get_type(((val).type_id)))))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+));
+JaktInternal::DynamicArray<types::ResolvedNamespace> const ns = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
+__jakt_var_353 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute(function_id,static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>>>(ns),JaktInternal::OptionalNone(),(TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>(TRY((utility::interpret_escapes(((val).to_string()))))))),span)})))),span,scope))));
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Return>();
 types::Value const& value = __jakt_match_value.value;
 return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(result);
-};/*case end*/
 case 1: {
-return JaktInternal::ExplicitValue(result);
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)); goto __jakt_label_356;
+)); goto __jakt_label_338;
 
 }
-__jakt_label_356:; __jakt_var_370.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)); goto __jakt_label_354;
-
+__jakt_label_338:; __jakt_var_353.release_value(); }));
 }
-__jakt_label_354:; __jakt_var_367.release_value(); }));
+}()))
+);
 };/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_350;
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CCharacterConstant>();DeprecatedString const& val = __jakt_match_value.val;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CChar>((infallible_integer_cast<char>((((val).byte_at(static_cast<size_t>(0ULL))))))))),span)) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CharacterConstant>();DeprecatedString const& val = __jakt_match_value.val;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_358; {
+DeprecatedStringCodePointIterator code_points = ((val).code_points());
+JaktInternal::Optional<u32> const code_point = ((code_points).next());
+if ((!(((code_point).has_value())))){
+TRY((((*this).error(Jakt::DeprecatedString("Invalid character constant"sv),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidCharacterConstant))));
+}
+__jakt_var_358 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((code_point.value())))),span)) } ; goto __jakt_label_343;
 
 }
-__jakt_label_350:; __jakt_var_362.release_value(); }));
+__jakt_label_343:; __jakt_var_358.release_value(); }));
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::EnumVariantArg>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedEnumVariantBinding const& arg = __jakt_match_value.arg;
-types::CheckedEnumVariant const& enum_variant = __jakt_match_value.enum_variant;
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& repeat = __jakt_match_value.repeat;
 utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_371; {
-types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((repeat).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_359; {
+size_t const count = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression((repeat.value()),scope))));
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
-};/*case end*/
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
@@ -15739,132 +15855,89 @@ types::Value const& value = __jakt_match_value.value;
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 };/*case end*/
-case 3: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
-}
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
 };/*case end*/
-case 4: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
-}
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
 };/*case end*/
-case 2: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
-}
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-__jakt_var_371 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
-types::EnumId const& enum_id = __jakt_match_value.enum_id;
-types::FunctionId const& constructor = __jakt_match_value.constructor;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_372; {
-JaktInternal::Optional<types::CheckedEnumVariant> found_variant = JaktInternal::OptionalNone();
-{
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((((((*this).program))->get_enum(enum_id))).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedEnumVariant variant = (_magic_value.value());
-{
-if ((((variant).name()) == ((enum_variant).name()))){
-(found_variant = variant);
-break;
-}
-}
-
-}
-}
-
-__jakt_var_372 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = (found_variant.value());
-switch(__jakt_match_variant.index()) {
-case 1: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[static_cast<i64>(0LL)])) } );
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
 };/*case end*/
 case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& variant_fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_373; {
-i64 i = static_cast<i64>(0LL);
-{
-JaktInternal::ArrayIterator<types::VarId> _magic = ((variant_fields).iterator());
-for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::VarId var_id = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const field = ((((*this).program))->get_variable(var_id));
-DeprecatedString const matched_name = ((arg).name).value_or_lazy_evaluated([&] { return ((arg).binding); });
-if ((matched_name == ((field)->name))){
-break;
-}
-({auto& _jakt_ref = i;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
-}
-
-}
-}
-
-__jakt_var_373 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[i])) } ; goto __jakt_label_359;
-
-}
-__jakt_label_359:; __jakt_var_373.release_value(); }));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),span)) } );
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
 };/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_358;
-
-}
-__jakt_label_358:; __jakt_var_372.release_value(); }));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((x))));
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Value matches cannot have enum variant arms (matching on {})"sv),((value).type_name())))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+utility::panic(Jakt::DeprecatedString("Invalid type for repeat"sv));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)); goto __jakt_label_357;
-
+)));
+};/*case end*/
+case 3: {
+{
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-__jakt_label_357:; __jakt_var_371.release_value(); }));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_374; {
-JaktInternal::DynamicArray<types::Value> fields = (TRY((DynamicArray<types::Value>::create_with({}))));
+case 4: {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
 {
-types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(val,scope))));
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+}
 };/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+types::Value const value_to_repeat = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(((vals)[static_cast<i64>(0LL)]),scope))));
+switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
@@ -15879,6 +15952,11 @@ types::Value const& value = __jakt_match_value.value;
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
 };/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
@@ -15890,6 +15968,8 @@ return ( interpreter::StatementResult { typename interpreter::StatementResult::B
 }
 };/*case end*/
 case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
@@ -15897,22 +15977,13 @@ utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-TRY((((fields).push(value))));
-}
+__jakt_var_359 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>((TRY((DynamicArray<types::Value>::filled(count, value_to_repeat)))),TRY((((((*this).program))->substitute_typevars_in_type(type_id,TRY((((scope)->type_map_for_substitution()))),((type_id).module)))))))),span)) } ; goto __jakt_label_344;
 
 }
+__jakt_label_344:; __jakt_var_359.release_value(); }));
 }
-
-__jakt_var_374 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktTuple>(fields,type_id))),span)) } ; goto __jakt_label_360;
-
-}
-__jakt_label_360:; __jakt_var_374.release_value(); }));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-utility::Span const& span = __jakt_match_value.span;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_375; {
+else {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_360; {
 JaktInternal::DynamicArray<types::Value> values = (TRY((DynamicArray<types::Value>::create_with({}))));
 {
 JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
@@ -15921,10 +15992,10 @@ JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename types::CheckedExpression> v = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedExpression> value = (_magic_value.value());
 {
 types::Value const val = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(v,scope))));
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(value,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -15971,192 +16042,25 @@ TRY((((values).push(val))));
 }
 }
 
-__jakt_var_375 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktSet>(values,type_id))),span)) } ; goto __jakt_label_361;
-
-}
-__jakt_label_361:; __jakt_var_375.release_value(); }));
-};/*case end*/
-case 30: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::DependentFunction>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
-JaktInternal::DynamicArray<types::CheckedParameter> const& params = __jakt_match_value.params;
-types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-parser::ParsedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-bool const& can_throw = __jakt_match_value.can_throw;
-types::ScopeId const& scope_id = __jakt_match_value.scope_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_376; {
-JaktInternal::Dictionary<DeprecatedString,types::Value> resolved_captures = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
-{
-JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedCapture capture = (_magic_value.value());
-{
-DeprecatedString const name = ((capture).name());
-if ((((capture).index() == 0 /* ByValue */) || ((capture).index() == 3 /* ByComptimeDependency */))){
-TRY((((resolved_captures).set(name,TRY((((scope)->must_get(name))))))));
-}
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot capture by reference in a comptime function (nyi)"sv)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-
-}
-
-}
-}
-
-types::GenericInferences const type_map = TRY((((scope)->type_map_for_substitution())));
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TypeId,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>> resolved_params = (TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TypeId,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>>::create_with_entries({}))));
-JaktInternal::DynamicArray<types::CheckedParameter> checked_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((params).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedParameter param = (_magic_value.value());
-{
-types::TypeId const param_type_id = TRY((((((*this).program))->substitute_typevars_in_type(((((param).variable))->type_id),type_map,((((((param).variable))->type_id)).module)))));
-TRY((((resolved_params).set(((((param).variable))->name),(Tuple{param_type_id, ((param).default_value)})))));
-TRY((((checked_params).push(types::CheckedParameter(((param).requires_label),TRY((types::CheckedVariable::__jakt_create(((((param).variable))->name),param_type_id,((((param).variable))->is_mutable),((((param).variable))->definition_span),((((param).variable))->type_span),((((param).variable))->visibility),JaktInternal::OptionalNone()))),((param).default_value))))));
-}
-
-}
-}
-
-types::CheckedBlock const fixed_block = TRY((((*this).perform_final_interpretation_pass(block,scope_id,TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))))))));
-__jakt_var_376 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Function>(resolved_captures,resolved_params,TRY((((((*this).program))->substitute_typevars_in_type(return_type_id,type_map,((return_type_id).module))))),TRY((((((*this).program))->substitute_typevars_in_type(type_id,type_map,((type_id).module))))),fixed_block,can_throw,checked_params,scope_id))),span)) } ; goto __jakt_label_362;
-
-}
-__jakt_label_362:; __jakt_var_376.release_value(); }));
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Function>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
-JaktInternal::DynamicArray<types::CheckedParameter> const& params = __jakt_match_value.params;
-types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-types::CheckedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-bool const& can_throw = __jakt_match_value.can_throw;
-types::ScopeId const& scope_id = __jakt_match_value.scope_id;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_377; {
-JaktInternal::Dictionary<DeprecatedString,types::Value> resolved_captures = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
-{
-JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedCapture capture = (_magic_value.value());
-{
-DeprecatedString const name = ((capture).name());
-if ((((capture).index() == 0 /* ByValue */) || ((capture).index() == 3 /* ByComptimeDependency */))){
-TRY((((resolved_captures).set(name,TRY((((scope)->must_get(name))))))));
-}
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot capture by reference in a comptime function (nyi)"sv)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
-}
-
-}
-
-}
-}
-
-types::GenericInferences const type_map = TRY((((scope)->type_map_for_substitution())));
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TypeId,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>> resolved_params = (TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TypeId,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>>::create_with_entries({}))));
-JaktInternal::DynamicArray<types::CheckedParameter> checked_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((params).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedParameter param = (_magic_value.value());
-{
-types::TypeId const param_type_id = TRY((((((*this).program))->substitute_typevars_in_type(((((param).variable))->type_id),type_map,((((((param).variable))->type_id)).module)))));
-TRY((((resolved_params).set(((((param).variable))->name),(Tuple{param_type_id, ((param).default_value)})))));
-TRY((((checked_params).push(types::CheckedParameter(((param).requires_label),TRY((types::CheckedVariable::__jakt_create(((((param).variable))->name),param_type_id,((((param).variable))->is_mutable),((((param).variable))->definition_span),((((param).variable))->type_span),((((param).variable))->visibility),JaktInternal::OptionalNone()))),((param).default_value))))));
-}
+__jakt_var_360 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(values,TRY((((((*this).program))->substitute_typevars_in_type(type_id,TRY((((scope)->type_map_for_substitution()))),((type_id).module)))))))),span)) } ; goto __jakt_label_345;
 
 }
+__jakt_label_345:; __jakt_var_360.release_value(); }));
 }
-
-types::CheckedBlock const fixed_block = TRY((((*this).perform_final_interpretation_pass(block,scope_id,TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))))))));
-__jakt_var_377 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Function>(resolved_captures,resolved_params,TRY((((((*this).program))->substitute_typevars_in_type(return_type_id,type_map,((return_type_id).module))))),TRY((((((*this).program))->substitute_typevars_in_type(type_id,type_map,((type_id).module))))),fixed_block,can_throw,checked_params,scope_id))),span)) } ; goto __jakt_label_363;
-
-}
-__jakt_label_363:; __jakt_var_377.release_value(); }));
+}()))
+);
 };/*case end*/
-case 32: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::TryBlock>();NonnullRefPtr<typename types::CheckedStatement> const& stmt = __jakt_match_value.stmt;
-types::CheckedBlock const& catch_block = __jakt_match_value.catch_block;
-DeprecatedString const& error_name = __jakt_match_value.error_name;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_378; {
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_statement(stmt,scope,span))));
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+size_t const& index = __jakt_match_value.index;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_361; {
+types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
 case 5: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
 types::Value const& value = __jakt_match_value.value;
-{
-NonnullRefPtr<interpreter::InterpreterScope> catch_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
-ScopeGuard __jakt_var_379([&] {
-MUST((((catch_scope)->perform_defers(*this,span))));
-});
-TRY((((((catch_scope)->bindings)).set(error_name,value))));
-interpreter::StatementResult const result = TRY((((*this).execute_block(catch_block,catch_scope,span))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = result;
-switch(__jakt_match_variant.index()) {
-case 3: {
-{
-return (result);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 4: {
-{
-return (result);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 0: {
-{
-return (result);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-{
-return (result);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -16164,87 +16068,73 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
+case 4: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-__jakt_var_378 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),span)) } ; goto __jakt_label_364;
-
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-__jakt_label_364:; __jakt_var_378.release_value(); }));
-};/*case end*/
-case 33: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Reflect>();types::TypeId const& type_id = __jakt_match_value.type;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((((*this).reflect_type(type_id,span,scope))))) } );
 };/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("expression not implemented: {}"sv),expr))),((expr)->span())))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+case 2: {
+{
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)));
+));
+__jakt_var_361 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((((value).impl))->index() == 26 /* JaktTuple */));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_362; {
+JaktInternal::DynamicArray<types::Value> const fields = ((((value).impl))->get<types::ValueImpl::JaktTuple>()).fields;
+__jakt_var_362 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[index])) } ; goto __jakt_label_347;
+
 }
+__jakt_label_347:; __jakt_var_362.release_value(); }));
 }
-
-ErrorOr<interpreter::StatementResult> interpreter::Interpreter::execute_statement(NonnullRefPtr<typename types::CheckedStatement> const statement,NonnullRefPtr<interpreter::InterpreterScope> scope,utility::Span const call_span) {
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *statement;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+else {
 {
-return (TRY((((*this).execute_expression(expr,scope)))));
+utility::panic(Jakt::DeprecatedString("expected tuple"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.statement;
-{
-TRY((((scope)->defer_statement(statement))));
 }
-return JaktInternal::ExplicitValue<void>();
+}()))
+; goto __jakt_label_346;
+
+}
+__jakt_label_346:; __jakt_var_361.release_value(); }));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& vars = __jakt_match_value.vars;
-NonnullRefPtr<typename types::CheckedStatement> const& var_decl = __jakt_match_value.var_decl;
-{
-if (((var_decl)->index() == 3 /* VarDecl */)){
-types::VarId const var_id = ((var_decl)->get<types::CheckedStatement::VarDecl>()).var_id;
-NonnullRefPtr<typename types::CheckedExpression> const init = ((var_decl)->get<types::CheckedStatement::VarDecl>()).init;
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(init,scope))));
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Match>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+JaktInternal::DynamicArray<types::CheckedMatchCase> const& match_cases = __jakt_match_value.match_cases;
+bool const& all_variants_constant = __jakt_match_value.all_variants_constant;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_363; {
+types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -16252,122 +16142,273 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& var_value = __jakt_match_value.value;
-{
-TRY(((scope)->bindings).set(((((((*this).program))->get_variable(var_id)))->name), var_value));
-}
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 2: {
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
+__jakt_var_363 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::EnumId const& enum_id = __jakt_match_value.enum_id;
+types::FunctionId const& constructor = __jakt_match_value.constructor;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_364; {
+DeprecatedString const constructor_name = ((((((*this).program))->get_function(constructor)))->name);
+JaktInternal::Optional<types::CheckedMatchBody> catch_all_case = JaktInternal::OptionalNone();
+JaktInternal::Optional<types::CheckedMatchBody> found_body = JaktInternal::OptionalNone();
+JaktInternal::Optional<JaktInternal::DynamicArray<parser::EnumVariantPatternArgument>> found_args = JaktInternal::OptionalNone();
+JaktInternal::Optional<size_t> found_variant_index = JaktInternal::OptionalNone();
+JaktInternal::Optional<utility::Span> span = JaktInternal::OptionalNone();
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedStatement>> _magic = ((vars).iterator());
+JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedMatchCase> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename types::CheckedStatement> var = (_magic_value.value());
+types::CheckedMatchCase match_case = (_magic_value.value());
 {
-if (((var)->index() == 3 /* VarDecl */)){
-types::VarId const var_id = ((var)->get<types::CheckedStatement::VarDecl>()).var_id;
-NonnullRefPtr<typename types::CheckedExpression> const init = ((var)->get<types::CheckedStatement::VarDecl>()).init;
 JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(init,scope))));
+auto&& __jakt_match_variant = match_case;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::EnumVariant>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& args = __jakt_match_value.args;
+size_t const& index = __jakt_match_value.index;
+types::CheckedMatchBody const& body = __jakt_match_value.body;
+utility::Span const& marker_span = __jakt_match_value.marker_span;
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+if ((name != constructor_name)){
+return JaktInternal::LoopContinue{};
+}
+(found_body = body);
+(found_args = args);
+(found_variant_index = index);
+(span = marker_span);
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::Expression>();utility::Span const& marker_span = __jakt_match_value.marker_span;
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+TRY((((*this).error(Jakt::DeprecatedString("Value matches are not allowed on enums"sv),marker_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& var_value = __jakt_match_value.value;
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
+utility::Span const& marker_span = __jakt_match_value.marker_span;
 {
-TRY(((scope)->bindings).set(((((((*this).program))->get_variable(var_id)))->name), var_value));
+(catch_all_case = body);
+(span = marker_span);
+return JaktInternal::LoopContinue{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+}
+
+}
+}
+
+(found_body = found_body.value_or_lazy_evaluated([&] { return (catch_all_case.value()); }));
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const empty_args = (TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({}))));
+(found_args = found_args.value_or_lazy_evaluated([&] { return empty_args; }));
+NonnullRefPtr<interpreter::InterpreterScope> new_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
+ScopeGuard __jakt_var_365([&] {
+MUST((((new_scope)->perform_defers(*this,(span.value())))));
+});
+if ((((found_variant_index).has_value()) && (!((((found_args.value())).is_empty()))))){
+types::CheckedEnumVariant const variant = ((((((((*this).program))->get_enum(enum_id))).variants))[(found_variant_index.value())]);
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 0: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
+case 2: {
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
+case 1: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+TRY((((((new_scope)->bindings)).set((((((found_args.value()))[static_cast<i64>(0LL)])).binding),((fields)[static_cast<i64>(0LL)])))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& variant_fields = __jakt_match_value.fields;
+{
+i64 i = static_cast<i64>(0LL);
+{
+JaktInternal::ArrayIterator<types::VarId> _magic = ((variant_fields).iterator());
+for (;;){
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::VarId var_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedVariable> const field = ((((*this).program))->get_variable(var_id));
+{
+JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = (((found_args.value())).iterator());
+for (;;){
+JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::EnumVariantPatternArgument arg = (_magic_value.value());
+{
+DeprecatedString const matched_name = ((arg).name).value_or_lazy_evaluated([&] { return ((arg).binding); });
+if ((matched_name == ((field)->name))){
+TRY((((((new_scope)->bindings)).set(((arg).binding),((fields)[i])))));
+break;
 }
-else {
-utility::panic(Jakt::DeprecatedString("expected vardecl"sv));
 }
 
+}
+}
+
+({auto& _jakt_ref = i;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
 }
 
 }
 }
 
 }
-else {
-utility::panic(Jakt::DeprecatedString("expected vardecl"sv));
-}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+}
+__jakt_var_364 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = (found_body.value());
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Expression>();
+NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_366; {
+interpreter::StatementResult const result = TRY((((*this).execute_expression(expr,new_scope))));
+__jakt_var_366 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = result;
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_350;
+
+}
+__jakt_label_350:; __jakt_var_366.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Block>();
+types::CheckedBlock const& block = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_367; {
+interpreter::StatementResult const result = TRY((((*this).execute_block(block,new_scope,(span.value())))));
+__jakt_var_367 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = result;
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_351;
+
+}
+__jakt_label_351:; __jakt_var_367.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_349;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_349:; __jakt_var_364.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();types::VarId const& var_id = __jakt_match_value.var_id;
-NonnullRefPtr<typename types::CheckedExpression> const& init = __jakt_match_value.init;
-utility::Span const& span = __jakt_match_value.span;
+default: {
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_368; {
+JaktInternal::Optional<types::CheckedMatchBody> catch_all_case = JaktInternal::OptionalNone();
+JaktInternal::Optional<types::CheckedMatchBody> found_body = JaktInternal::OptionalNone();
+JaktInternal::Optional<utility::Span> span = JaktInternal::OptionalNone();
 {
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(init,scope))));
+JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedMatchCase> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedMatchCase match_case = (_magic_value.value());
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = match_case;
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::Expression>();types::CheckedMatchBody const& body = __jakt_match_value.body;
+NonnullRefPtr<typename types::CheckedExpression> const& expression = __jakt_match_value.expression;
+utility::Span const& marker_span = __jakt_match_value.marker_span;
+{
+types::Value const value_to_match_against = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expression,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
@@ -16375,7 +16416,6 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -16383,238 +16423,176 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& var_value = __jakt_match_value.value;
-{
-TRY(((scope)->bindings).set(((((((*this).program))->get_variable(var_id)))->name), var_value));
-}
-return JaktInternal::ExplicitValue<void>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 2: {
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
+if (((((value_to_match_against).impl))->equals(((value).impl)))){
+(found_body = static_cast<JaktInternal::Optional<types::CheckedMatchBody>>(body));
+(span = static_cast<JaktInternal::Optional<utility::Span>>(marker_span));
+return JaktInternal::LoopBreak{};
+}
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& then_block = __jakt_match_value.then_block;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
-utility::Span const& span = __jakt_match_value.span;
-{
-bool const cond = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(condition,scope))));
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::Bool>();
-bool const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
-};/*case end*/
-default: {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::CatchAll>();types::CheckedMatchBody const& body = __jakt_match_value.body;
+utility::Span const& marker_span = __jakt_match_value.marker_span;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("if condition must be a boolean, but got {}"sv),((value).impl)))),span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+(catch_all_case = body);
+(span = marker_span);
+return JaktInternal::LoopContinue{};
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
-}
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-}
-};/*case end*/
-case 3: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
-}
-};/*case end*/
-case 4: {
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
-}
-};/*case end*/
-case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedMatchCase::EnumVariant>();utility::Span const& marker_span = __jakt_match_value.marker_span;
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Value matches cannot have enum variant arms (matching on {})"sv),((value).type_name())))),marker_span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-JaktInternal::Optional<types::CheckedBlock> const block = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::CheckedBlock>,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (cond);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::CheckedBlock>>(then_block));
-}
-else {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::CheckedBlock>,ErrorOr<interpreter::StatementResult>>{
-auto __jakt_enum_value = (((else_statement).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::CheckedBlock>>(types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({(else_statement.value())})))),((then_block).scope_id), types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,JaktInternal::OptionalNone(),false)));
 }
-else {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+
 }
-}()))
-);
 }
-}()))
-;
-if (((block).has_value())){
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_block((block.value()),scope,span))));
+
+(found_body = found_body.value_or_lazy_evaluated([&] { return (catch_all_case.value()); }));
+NonnullRefPtr<interpreter::InterpreterScope> new_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
+ScopeGuard __jakt_var_369([&] {
+MUST((((new_scope)->perform_defers(*this,(span.value())))));
+});
+__jakt_var_368 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = (found_body.value());
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Expression>();
+NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_370; {
+interpreter::StatementResult const result = TRY((((*this).execute_expression(expr,new_scope))));
+__jakt_var_370 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = result;
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
 types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),span)) } );
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+return JaktInternal::ExplicitValue(result);
 };/*case end*/
 case 4: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
-};/*case end*/
-case 2: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
-}
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(result);
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-{
-NonnullRefPtr<interpreter::InterpreterScope> new_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
-ScopeGuard __jakt_var_380([&] {
-MUST((((new_scope)->perform_defers(*this,span))));
-});
-return (TRY((((*this).execute_block(block,new_scope,span)))));
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(result);
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-{
-for (;;){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_block(block,scope,span))));
-switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_353;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_353:; __jakt_var_370.release_value(); }));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedMatchBody::Block>();
+types::CheckedBlock const& block = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_371; {
+interpreter::StatementResult const result = TRY((((*this).execute_block(block,new_scope,(span.value())))));
+__jakt_var_371 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = result;
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
 types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(value) } );
 };/*case end*/
 case 3: {
-{
-return JaktInternal::LoopContinue{};
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(result);
 };/*case end*/
 case 4: {
-{
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(result);
 };/*case end*/
 case 5: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(result);
 };/*case end*/
-case 2: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+case 0: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(result);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_354;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_354:; __jakt_var_371.release_value(); }));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-));
+)); goto __jakt_label_352;
+
 }
+__jakt_label_352:; __jakt_var_368.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)); goto __jakt_label_348;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_348:; __jakt_var_363.release_value(); }));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& block = __jakt_match_value.block;
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::EnumVariantArg>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedEnumVariantBinding const& arg = __jakt_match_value.arg;
+types::CheckedEnumVariant const& enum_variant = __jakt_match_value.enum_variant;
 utility::Span const& span = __jakt_match_value.span;
-{
-for (;;){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(condition,scope))));
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_372; {
+types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
 switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -16622,156 +16600,139 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& x = __jakt_match_value.value;
-{
-if (((((x).impl))->index() == 1 /* Bool */)){
-bool const cond = ((((x).impl))->get<types::ValueImpl::Bool>()).value;
-if ((!(cond))){
-return JaktInternal::LoopBreak{};
-}
-}
-}
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 2: {
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_block(block,scope,span))));
+__jakt_var_372 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = *((value).impl);
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();JaktInternal::DynamicArray<types::Value> const& fields = __jakt_match_value.fields;
+types::EnumId const& enum_id = __jakt_match_value.enum_id;
+types::FunctionId const& constructor = __jakt_match_value.constructor;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_373; {
+JaktInternal::Optional<types::CheckedEnumVariant> found_variant = JaktInternal::OptionalNone();
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((((((*this).program))->get_enum(enum_id))).variants)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+if ((((variant).name()) == ((enum_variant).name()))){
+(found_variant = variant);
+break;
 }
-return JaktInternal::ExplicitValue<void>();
+}
+
+}
+}
+
+__jakt_var_373 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = (found_variant.value());
+switch(__jakt_match_variant.index()) {
+case 1: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[static_cast<i64>(0LL)])) } );
 };/*case end*/
 case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();JaktInternal::DynamicArray<types::VarId> const& variant_fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_374; {
+i64 i = static_cast<i64>(0LL);
 {
-return JaktInternal::LoopContinue{};
+JaktInternal::ArrayIterator<types::VarId> _magic = ((variant_fields).iterator());
+for (;;){
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 4: {
+types::VarId var_id = (_magic_value.value());
 {
-return JaktInternal::LoopBreak{};
+NonnullRefPtr<types::CheckedVariable> const field = ((((*this).program))->get_variable(var_id));
+DeprecatedString const matched_name = ((arg).name).value_or_lazy_evaluated([&] { return ((arg).binding); });
+if ((matched_name == ((field)->name))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 5: {
-{
+({auto& _jakt_ref = i;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
 }
+
+__jakt_var_374 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(((fields)[i])) } ; goto __jakt_label_357;
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const& val = __jakt_match_value.val;
-{
-if (((val).has_value())){
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression((val.value()),scope))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
+__jakt_label_357:; __jakt_var_374.release_value(); }));
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+default: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),span)) } );
 };/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+}/*switch end*/
+}()
+)); goto __jakt_label_356;
+
+}
+__jakt_label_356:; __jakt_var_373.release_value(); }));
 };/*case end*/
-case 2: {
+default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Value matches cannot have enum variant arms (matching on {})"sv),((value).type_name())))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
 }
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
-)));
-}
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } );
+)); goto __jakt_label_355;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_355:; __jakt_var_372.release_value(); }));
 };/*case end*/
-case 9: {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_375; {
+JaktInternal::DynamicArray<types::Value> fields = (TRY((DynamicArray<types::Value>::create_with({}))));
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 10: {
+NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
+types::Value const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(val,scope))));
 switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
 types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Yield(value) } );
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -16779,58 +16740,60 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
-}
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 2: {
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-))), JaktInternal::ExplicitValue<void>();
+));
+TRY((((fields).push(value))));
+}
+
+}
+}
+
+__jakt_var_375 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktTuple>(fields,type_id))),span)) } ; goto __jakt_label_358;
+
+}
+__jakt_label_358:; __jakt_var_375.release_value(); }));
 };/*case end*/
 case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_expression(expr,scope))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_376; {
+JaktInternal::DynamicArray<types::Value> values = (TRY((DynamicArray<types::Value>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename types::CheckedExpression> v = (_magic_value.value());
+{
+types::Value const val = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression(v,scope))));
 switch(__jakt_match_variant.index()) {
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
 types::Value const& value = __jakt_match_value.value;
 {
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-{
-return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
@@ -16838,465 +16801,700 @@ types::Value const& value = __jakt_match_value.value;
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
 }
-return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
 };/*case end*/
 case 3: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
 {
 return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& expr = __jakt_match_value.value;
 {
 utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-))), JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::InlineCpp>();utility::Span const& span = __jakt_match_value.span;
-return (TRY((((*this).error(Jakt::DeprecatedString("Cannot run inline cpp at compile time"sv),span))))), JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedStatement::Garbage>();
-utility::Span const& span = __jakt_match_value.value;
-return (TRY((((*this).error(Jakt::DeprecatedString("Cannot run invalid statements at compile time"sv),span))))), JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-return ( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),call_span)) } );
+TRY((((values).push(val))));
+}
+
 }
 }
 
-ErrorOr<interpreter::ExecutionResult> interpreter::Interpreter::execute(types::FunctionId const function_to_run_id,JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> namespace_,JaktInternal::Optional<types::Value> const this_argument,JaktInternal::DynamicArray<types::Value> const arguments,utility::Span const call_span,JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const invocation_scope) {
+__jakt_var_376 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktSet>(values,type_id))),span)) } ; goto __jakt_label_359;
+
+}
+__jakt_label_359:; __jakt_var_376.release_value(); }));
+};/*case end*/
+case 30: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::DependentFunction>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
+JaktInternal::DynamicArray<types::CheckedParameter> const& params = __jakt_match_value.params;
+types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+parser::ParsedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+bool const& can_throw = __jakt_match_value.can_throw;
+types::ScopeId const& scope_id = __jakt_match_value.scope_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_377; {
+JaktInternal::Dictionary<DeprecatedString,types::Value> resolved_captures = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
 {
-NonnullRefPtr<types::CheckedFunction> const function_to_run = ((((*this).program))->get_function(function_to_run_id));
-TRY((((*this).enter_span(call_span))));
-JaktInternal::Optional<types::FunctionId> const old_function_id = ((*this).current_function_id);
-(((*this).current_function_id) = function_to_run_id);
-ScopeGuard __jakt_var_381([&] {
+JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedCapture capture = (_magic_value.value());
 {
-(((*this).current_function_id) = old_function_id);
-((*this).leave_span());
+DeprecatedString const name = ((capture).name());
+if ((((capture).index() == 0 /* ByValue */) || ((capture).index() == 3 /* ByComptimeDependency */))){
+TRY((((resolved_captures).set(name,TRY((((scope)->must_get(name))))))));
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot capture by reference in a comptime function (nyi)"sv)))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
 
-});
-bool is_prelude_function = false;
-if (((((function_to_run)->linkage)).index() == 1 /* External */)){
-NonnullRefPtr<types::Scope> const function_scope = TRY((((((*this).program))->get_scope(((function_to_run)->function_scope_id)))));
-if ((!(TRY((((*this).get_prelude_function(((function_to_run)->function_scope_id)))))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot call external function '{}'"sv),((function_to_run)->name)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::CallToExternalFunction))));
 }
-(is_prelude_function = true);
+
 }
-if ((((function_to_run)->is_static()) == ((this_argument).has_value()))){
-DeprecatedString expected = Jakt::DeprecatedString("did not expect"sv);
-if ((!(((function_to_run)->is_static())))){
-(expected = Jakt::DeprecatedString("expected"sv));
 }
-DeprecatedString not_provided = Jakt::DeprecatedString(" not"sv);
-if (((this_argument).has_value())){
-(not_provided = Jakt::DeprecatedString(""sv));
+
+types::GenericInferences const type_map = TRY((((scope)->type_map_for_substitution())));
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TypeId,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>> resolved_params = (TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TypeId,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>>::create_with_entries({}))));
+JaktInternal::DynamicArray<types::CheckedParameter> checked_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((params).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::Message(TRY((__jakt_format(Jakt::DeprecatedString("function call {} a this argument, yet one was{} provided"sv),expected,not_provided))),((function_to_run)->name_span)) } ))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidThisArgument))));
+types::CheckedParameter param = (_magic_value.value());
+{
+types::TypeId const param_type_id = TRY((((((*this).program))->substitute_typevars_in_type(((((param).variable))->type_id),type_map,((((((param).variable))->type_id)).module)))));
+TRY((((resolved_params).set(((((param).variable))->name),(Tuple{param_type_id, ((param).default_value)})))));
+TRY((((checked_params).push(types::CheckedParameter(((param).requires_label),TRY((types::CheckedVariable::__jakt_create(((((param).variable))->name),param_type_id,((((param).variable))->is_mutable),((((param).variable))->definition_span),((((param).variable))->type_span),((((param).variable))->visibility),JaktInternal::OptionalNone()))),((param).default_value))))));
 }
-size_t this_offset = static_cast<size_t>(0ULL);
-if (((this_argument).has_value())){
-(this_offset = static_cast<size_t>(1ULL));
+
 }
-if (((JaktInternal::checked_sub<size_t>(((((function_to_run)->params)).size()),this_offset)) != ((arguments).size()))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Function called with wrong number of arguments, expected {} but got {}"sv),((((function_to_run)->params)).size()),((arguments).size())))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::MismatchingArguments))));
 }
-if (is_prelude_function){
-if ((((this_argument).has_value()) && ((!(((namespace_).has_value()))) || (((namespace_.value())).is_empty())))){
-JaktInternal::DynamicArray<types::ResolvedNamespace> effective_namespace = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = *(((this_argument.value())).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-{
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("String"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+
+types::CheckedBlock const fixed_block = TRY((((*this).perform_final_interpretation_pass(block,scope_id,TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))))))));
+__jakt_var_377 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Function>(resolved_captures,resolved_params,TRY((((((*this).program))->substitute_typevars_in_type(return_type_id,type_map,((return_type_id).module))))),TRY((((((*this).program))->substitute_typevars_in_type(type_id,type_map,((type_id).module))))),fixed_block,can_throw,checked_params,scope_id))),span)) } ; goto __jakt_label_360;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_360:; __jakt_var_377.release_value(); }));
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();types::TypeId const& type_id = __jakt_match_value.type_id;
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Function>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
+JaktInternal::DynamicArray<types::CheckedParameter> const& params = __jakt_match_value.params;
+types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+types::CheckedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+bool const& can_throw = __jakt_match_value.can_throw;
+types::ScopeId const& scope_id = __jakt_match_value.scope_id;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_378; {
+JaktInternal::Dictionary<DeprecatedString,types::Value> resolved_captures = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
 {
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(args);
-};/*case end*/
-default: {
+JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedCapture capture = (_magic_value.value());
 {
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic array"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+DeprecatedString const name = ((capture).name());
+if ((((capture).index() == 0 /* ByValue */) || ((capture).index() == 3 /* ByComptimeDependency */))){
+TRY((((resolved_captures).set(name,TRY((((scope)->must_get(name))))))));
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot capture by reference in a comptime function (nyi)"sv)))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+
+}
+
 }
+}
+
+types::GenericInferences const type_map = TRY((((scope)->type_map_for_substitution())));
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TypeId,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>> resolved_params = (TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TypeId,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>>::create_with_entries({}))));
+JaktInternal::DynamicArray<types::CheckedParameter> checked_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((params).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedParameter param = (_magic_value.value());
+{
+types::TypeId const param_type_id = TRY((((((*this).program))->substitute_typevars_in_type(((((param).variable))->type_id),type_map,((((((param).variable))->type_id)).module)))));
+TRY((((resolved_params).set(((((param).variable))->name),(Tuple{param_type_id, ((param).default_value)})))));
+TRY((((checked_params).push(types::CheckedParameter(((param).requires_label),TRY((types::CheckedVariable::__jakt_create(((((param).variable))->name),param_type_id,((((param).variable))->is_mutable),((((param).variable))->definition_span),((((param).variable))->type_span),((((param).variable))->visibility),JaktInternal::OptionalNone()))),((param).default_value))))));
+}
+
+}
+}
+
+types::CheckedBlock const fixed_block = TRY((((*this).perform_final_interpretation_pass(block,scope_id,TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))))))));
+__jakt_var_378 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Function>(resolved_captures,resolved_params,TRY((((((*this).program))->substitute_typevars_in_type(return_type_id,type_map,((return_type_id).module))))),TRY((((((*this).program))->substitute_typevars_in_type(type_id,type_map,((type_id).module))))),fixed_block,can_throw,checked_params,scope_id))),span)) } ; goto __jakt_label_361;
+
+}
+__jakt_label_361:; __jakt_var_378.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Array"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+case 32: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::TryBlock>();NonnullRefPtr<typename types::CheckedStatement> const& stmt = __jakt_match_value.stmt;
+types::CheckedBlock const& catch_block = __jakt_match_value.catch_block;
+DeprecatedString const& error_name = __jakt_match_value.error_name;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<interpreter::StatementResult> __jakt_var_379; {
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_statement(stmt,scope,span))));
+switch(__jakt_match_variant.index()) {
+case 5: {
+{
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktDictionary>();types::TypeId const& type_id = __jakt_match_value.type_id;
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
 {
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::TypeId>, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+NonnullRefPtr<interpreter::InterpreterScope> catch_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
+ScopeGuard __jakt_var_380([&] {
+MUST((((catch_scope)->perform_defers(*this,span))));
+});
+TRY((((((catch_scope)->bindings)).set(error_name,value))));
+interpreter::StatementResult const result = TRY((((*this).execute_block(catch_block,catch_scope,span))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = result;
 switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(args);
-};/*case end*/
-default: {
+case 3: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic dictionary"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+return (result);
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Dictionary"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+case 4: {
+{
+return (result);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktSet>();types::TypeId const& type_id = __jakt_match_value.type_id;
+case 0: {
 {
-if (((((((*this).program))->get_type(type_id)))->index() == 19 /* GenericInstance */)){
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = ((((((*this).program))->get_type(type_id)))->get<types::Type::GenericInstance>()).args;
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Set"sv),JaktInternal::OptionalNone(),generic_parameters)))));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to call a prelude function  on a non-generic set"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+return (result);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+{
+return (result);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Struct>();types::StructId const& struct_id = __jakt_match_value.struct_id;
+default: {
 {
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_struct(struct_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Class>();types::StructId const& struct_id = __jakt_match_value.struct_id;
+}/*switch end*/
+}()
+));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
 {
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_struct(struct_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Return(value) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::Enum>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
+case 4: {
 {
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(((((((*this).program))->get_enum(enum_id))).name),JaktInternal::OptionalNone(),generic_parameters)))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 25: {
+case 3: {
 {
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Optional"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+return ( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 24: {
+case 2: {
 {
-JaktInternal::DynamicArray<types::TypeId> const generic_parameters = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((effective_namespace).push(types::ResolvedNamespace(Jakt::DeprecatedString("Optional"sv),JaktInternal::OptionalNone(),generic_parameters)))));
+utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+__jakt_var_379 =  interpreter::StatementResult { typename interpreter::StatementResult::JustValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Void>())),span)) } ; goto __jakt_label_362;
+
+}
+__jakt_label_362:; __jakt_var_379.release_value(); }));
+};/*case end*/
+case 33: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Reflect>();types::TypeId const& type_id = __jakt_match_value.type;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((((*this).reflect_type(type_id,span,scope))))) } );
+};/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Attempted to call an instance method on a non-struct/enum type"sv),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("expression not implemented: {}"sv),expr))),((expr)->span())))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-));
-(namespace_ = effective_namespace);
+)));
 }
-JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings = (TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({}))));
-if (((invocation_scope).has_value())){
-(type_bindings = (((invocation_scope.value()))->type_bindings));
 }
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::ExecutionResult, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = TRY((((*this).call_prelude_function(((function_to_run)->name),(namespace_.value()),this_argument,arguments,call_span,type_bindings))));
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> interpreter::Interpreter::perform_final_interpretation_expr_pass(NonnullRefPtr<typename types::CheckedExpression> const expr,NonnullRefPtr<interpreter::InterpreterScope> const scope) {
+{
+if (((expr)->index() == 6 /* UnaryOp */)){
+types::CheckedUnaryOperator const op = ((expr)->get<types::CheckedExpression::UnaryOp>()).op;
+if (((op).index() == 11 /* TypeCast */)){
+warnln(Jakt::DeprecatedString("{0:c}[31mFixup{0:c}[0m {1}"sv),static_cast<i64>(27LL),expr);
+}
+}
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *expr;
+switch(__jakt_match_variant.index()) {
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ComptimeIndex>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+NonnullRefPtr<typename types::CheckedExpression> const& index = __jakt_match_value.index;
+bool const& is_optional = __jakt_match_value.is_optional;
+utility::Span const& span = __jakt_match_value.span;
+{
+interpreter::StatementResult const index_result = TRY((((*this).execute_expression(index,scope))));
+types::NumericOrStringValue const index_constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::NumericOrStringValue, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = index_result;
 switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
 types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(value) } );
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(value) } );
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::NumericOrStringValue, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::StringValue(val) } );
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Throw(value) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
 };/*case end*/
 case 3: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
-}
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
 };/*case end*/
 case 4: {
-{
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
-}
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
 };/*case end*/
-case 2: {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumericOrStringValue { typename types::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+};/*case end*/
+default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index expression evaluation failed: expected numeric or string type, found {}"sv),((value).impl)))),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
 }
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index expression evaluation returned an invalid object {}"sv),index_result))),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = ((function_to_run)->type);
+};/*case end*/
+}/*switch end*/
+}()
+));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = index_constant;
 switch(__jakt_match_variant.index()) {
 case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumericOrStringValue::StringValue>();
+DeprecatedString const& field = __jakt_match_value.value;
 {
-NonnullRefPtr<interpreter::InterpreterScope> scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),invocation_scope,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))))));
-ScopeGuard __jakt_var_382([&] {
+types::TypeId const checked_expr_type_id = TRY((((scope)->map_type(((expr)->type())))));
+NonnullRefPtr<typename types::Type> const checked_expr_type = ((((*this).program))->get_type(checked_expr_type_id));
+types::StructId const optional_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *checked_expr_type;
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
 {
-MUST((((scope)->perform_defers(*this,call_span))));
+types::TypeId type_id = checked_expr_type_id;
+if (is_optional){
+if ((!(((id).equals(optional_struct_id))))){
+TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is only allowed on optional types"sv),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
 }
-
-});
+(type_id = ((args)[static_cast<i64>(0LL)]));
+}
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((((*this).program))->get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((function_to_run)->params)).size()))});
+types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+types::CheckedField member_id = (_magic_value.value());
 {
-if (((this_offset != static_cast<size_t>(0ULL)) && (i == static_cast<size_t>(0ULL)))){
-continue;
+NonnullRefPtr<types::CheckedVariable> const member = ((((*this).program))->get_variable(((member_id).variable_id)));
+if ((((member)->name) == field)){
+types::TypeId resolved_type_id = TRY((((scope)->map_type(((member)->type_id)))));
+if (is_optional){
+(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+}
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(expr,field,span,is_optional,resolved_type_id))));
 }
-DeprecatedString const param_name = ((((((((function_to_run)->params))[i])).variable))->name);
-types::Value const param_value = ((arguments)[(JaktInternal::checked_sub<size_t>(i,this_offset))]);
-TRY(((scope)->bindings).set(param_name, param_value));
 }
 
 }
 }
 
-if (((this_argument).has_value())){
-TRY((((((scope)->bindings)).set(Jakt::DeprecatedString("this"sv),(this_argument.value())))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
 }
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::ExecutionResult, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = TRY((((*this).execute_block(((function_to_run)->block),scope,call_span))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(TRY((interpreter::cast_value_to_type(value,((function_to_run)->return_type_id),*this,false)))) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(TRY((interpreter::cast_value_to_type(value,((function_to_run)->return_type_id),*this,false)))) } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Throw(value) } );
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-case 4: {
+types::CheckedField member_id = (_magic_value.value());
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+NonnullRefPtr<types::CheckedVariable> const member = ((((*this).program))->get_variable(((member_id).variable_id)));
+if ((((member)->name) == field)){
+types::TypeId resolved_type_id = TRY((((scope)->map_type(((member)->type_id)))));
+if (is_optional){
+(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+}
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(expr,field,span,is_optional,resolved_type_id))));
+}
 }
+
+}
+}
+
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
+default: {
 {
-utility::panic(Jakt::DeprecatedString("Invalid control flow"sv));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Member field access on value of non-struct type ‘{}’"sv),TRY((((((*this).program))->type_name(checked_expr_type_id,false))))))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
-)));
+));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-{
-NonnullRefPtr<typename types::Type> const result_type = ((((*this).program))->get_type(((function_to_run)->return_type_id)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = *result_type;
-switch(__jakt_match_variant.index()) {
 case 23: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
 types::StructId const& struct_id = __jakt_match_value.value;
 {
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-types::FunctionId const constructor = function_to_run_id;
-NonnullRefPtr<typename types::ValueImpl> const impl = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = ((struct_).record_type);
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>(arguments,struct_id,constructor))));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Class>(arguments,struct_id,constructor))));
+if (is_optional){
+TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on non-optional types"sv),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+}
+types::CheckedStruct const structure = ((((*this).program))->get_struct(struct_id));
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedField member_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedVariable> const member = ((((*this).program))->get_variable(((member_id).variable_id)));
+if ((((member)->name) == field)){
+types::TypeId const resolved_type_id = TRY((((scope)->map_type(((member)->type_id)))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(expr,field,span,is_optional,resolved_type_id))));
+}
+}
+
+}
+}
+
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot create instance of non-struct type {}"sv),((struct_).name)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Member field access on value of non-struct type ‘{}’"sv),TRY((((((*this).program))->type_name(checked_expr_type_id,false))))))),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidOperation))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-return ( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(types::Value(impl,call_span)) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumericOrStringValue::UnsignedNumericValue>();
+u64 const& val = __jakt_match_value.value;
 {
-types::CheckedStruct const struct_ = ((((*this).program))->get_struct(struct_id));
-types::FunctionId const constructor = function_to_run_id;
-NonnullRefPtr<typename types::ValueImpl> const impl = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::ValueImpl>, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = ((struct_).record_type);
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Struct>(arguments,struct_id,constructor))));
+TRY((((*this).error(Jakt::DeprecatedString("Unimplemented expression"sv),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 1: {
-return JaktInternal::ExplicitValue(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Class>(arguments,struct_id,constructor))));
-};/*case end*/
-default: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumericOrStringValue::SignedNumericValue>();
+i64 const& val = __jakt_match_value.value;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot create instance of non-struct type {}"sv),((struct_).name)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((*this).error(Jakt::DeprecatedString("Unimplemented expression"sv),span))));
+return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-return ( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(types::Value(impl,call_span)) } );
 }
-return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedUnaryOperator const& op = __jakt_match_value.op;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedUnaryOperator, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::TypeCast>();
+types::CheckedTypeCast const& cast = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::TypeCast(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedTypeCast, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = cast;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Fallible>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::CheckedTypeCast { typename types::CheckedTypeCast::Fallible(TRY((((scope)->map_type(type_id))))) } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Infallible>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::CheckedTypeCast { typename types::CheckedTypeCast::Infallible(TRY((((scope)->map_type(type_id))))) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+))) } );
 };/*case end*/
 default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Implicit constructor can only return a struct or a generic instance"sv)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(op);
 };/*case end*/
 }/*switch end*/
 }()
-));
-}
-return JaktInternal::ExplicitValue<void>();
+)),span,TRY((((scope)->map_type(type_id))))))));
 };/*case end*/
-case 3: {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& lhs = __jakt_match_value.lhs;
+parser::BinaryOperator const& op = __jakt_match_value.op;
+NonnullRefPtr<typename types::CheckedExpression> const& rhs = __jakt_match_value.rhs;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::BinaryOp>(TRY((((*this).perform_final_interpretation_expr_pass(lhs,scope)))),op,TRY((((*this).perform_final_interpretation_expr_pass(rhs,scope)))),span,TRY((((scope)->map_type(type_id))))))));
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
+utility::Span const& span = __jakt_match_value.span;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_381; {
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> new_args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
 {
-NonnullRefPtr<typename types::Type> const result_type = ((((*this).program))->get_type(((function_to_run)->return_type_id)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<interpreter::ExecutionResult>>{
-auto&& __jakt_match_variant = *result_type;
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
 {
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-types::FunctionId const constructor = function_to_run_id;
-NonnullRefPtr<typename types::ValueImpl> const impl = TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>(arguments,enum_id,constructor)));
-return ( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(types::Value(impl,call_span)) } );
+TRY((((new_args).push((Tuple{((arg).template get<0>()), TRY((((*this).perform_final_interpretation_expr_pass(((arg).template get<1>()),scope))))})))));
 }
-return JaktInternal::ExplicitValue<void>();
+
+}
+}
+
+__jakt_var_381 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Call>(types::CheckedCall(((call).namespace_),((call).name),new_args,((call).type_args),((call).function_id),((call).return_type),((call).callee_throws),JaktInternal::OptionalNone()),span,type_id))); goto __jakt_label_363;
+
+}
+__jakt_label_363:; __jakt_var_381.release_value(); }));
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedCall const& call = __jakt_match_value.call;
+utility::Span const& span = __jakt_match_value.span;
+bool const& is_optional = __jakt_match_value.is_optional;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_382; {
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> new_args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
 {
-types::CheckedEnum const enum_ = ((((*this).program))->get_enum(enum_id));
-types::FunctionId const constructor = function_to_run_id;
-NonnullRefPtr<typename types::ValueImpl> const impl = TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::Enum>(arguments,enum_id,constructor)));
-return ( interpreter::ExecutionResult { typename interpreter::ExecutionResult::Return(types::Value(impl,call_span)) } );
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> arg = (_magic_value.value());
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Implicit enum constructor can only return an enum or a generic instance of one"sv)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::InvalidType))));
+TRY((((new_args).push((Tuple{((arg).template get<0>()), TRY((((*this).perform_final_interpretation_expr_pass(((arg).template get<1>()),scope))))})))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+
 }
-return JaktInternal::ExplicitValue<void>();
+}
+
+__jakt_var_382 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::MethodCall>(TRY((((*this).perform_final_interpretation_expr_pass(expr,scope)))),types::CheckedCall(((call).namespace_),((call).name),new_args,((call).type_args),((call).function_id),((call).return_type),((call).callee_throws),JaktInternal::OptionalNone()),span,is_optional,type_id))); goto __jakt_label_364;
+
+}
+__jakt_label_364:; __jakt_var_382.release_value(); }));
 };/*case end*/
 default: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(expr);
 };/*case end*/
 }/*switch end*/
 }()
-));
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Function type {} is not implemented"sv),((function_to_run)->type)))),call_span))));
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::Unimplemented))));
+)));
 }
 }
 
-ErrorOr<types::CheckedBlock> interpreter::Interpreter::invoke_typecheck_block(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> const& function,parser::ParsedBlock const block,types::ScopeId const parent_scope_id) {
+ErrorOr<interpreter::StatementResult> interpreter::Interpreter::execute_expression(NonnullRefPtr<typename types::CheckedExpression> const expr,NonnullRefPtr<interpreter::InterpreterScope> scope) {
 {
-return (TRY((function(block,parent_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult,ErrorOr<interpreter::StatementResult>>{
+auto __jakt_enum_value = (((((*this).current_function_id)).has_value()));
+if (__jakt_enum_value == false) {
+return JaktInternal::ExplicitValue(TRY((((*this).execute_expression_without_cast(expr,scope)))));
+}
+else {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<interpreter::StatementResult>>{
+auto&& __jakt_match_variant = TRY((((*this).execute_expression_without_cast(expr,scope))));
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Return(TRY((interpreter::cast_value_to_type(value,((((((*this).program))->get_function((((*this).current_function_id).value()))))->return_type_id),*this,false)))) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::JustValue(TRY((interpreter::cast_value_to_type(value,((expr)->type()),*this,false)))) } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Throw(value) } );
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Yield>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Yield(value) } );
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Break() } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( interpreter::StatementResult { typename interpreter::StatementResult::Continue() } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}()))
+);
 }
 }
 
-ErrorOr<types::TypeId> interpreter::Interpreter::tuple_type(JaktInternal::DynamicArray<types::TypeId> const members) {
+ErrorOr<types::CheckedBlock> interpreter::Interpreter::invoke_typecheck_block(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> const& function,parser::ParsedBlock const block,types::ScopeId const parent_scope_id) {
 {
-types::StructId const tuple_struct_id = TRY((((((*this).program))->find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
-NonnullRefPtr<typename types::Type> const type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(tuple_struct_id,members)));
-return (TRY((((*this).find_or_add_type_id(type)))));
+return (TRY((function(block,parent_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
 }
 }
 
@@ -18204,230 +18402,16 @@ return (result);
 }
 }
 
-ErrorOr<DeprecatedString> interpreter::InterpreterScope::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("InterpreterScope("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("bindings: {}, ", bindings));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parent: {}, ", parent));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_bindings: {}, ", type_bindings));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("defers: {}", defers));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<void> interpreter::InterpreterScope::defer_statement(NonnullRefPtr<typename types::CheckedStatement> const statement) {
-{
-TRY((((((*this).defers)).push( interpreter::Deferred { typename interpreter::Deferred::Statement(statement) } ))));
-}
-return {};
-}
-
-ErrorOr<void> interpreter::InterpreterScope::perform_defers(NonnullRefPtr<interpreter::Interpreter> interpreter,utility::Span const span) {
-{
-while ((!(((((*this).defers)).is_empty())))){
-JaktInternal::Optional<interpreter::Deferred> const deferred = ((((*this).defers)).pop());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<interpreter::StatementResult, ErrorOr<void>>{
-auto&& __jakt_match_variant = (deferred.value());
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::Deferred::Expression>();
-NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((interpreter)->execute_expression(expr,*this)))));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::Deferred::Statement>();
-NonnullRefPtr<typename types::CheckedStatement> const& statement = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((interpreter)->execute_statement(statement,*this,span)))));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-}
-}
-return {};
-}
-
-ErrorOr<NonnullRefPtr<interpreter::InterpreterScope>> interpreter::InterpreterScope::from_runtime_scope(types::ScopeId const scope_id,NonnullRefPtr<types::CheckedProgram> const program,JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const parent) {
-{
-JaktInternal::Dictionary<DeprecatedString,types::Value> bindings = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
-JaktInternal::Optional<types::ScopeId> current_id = scope_id;
-while (((current_id).has_value())){
-NonnullRefPtr<types::Scope> const scope = TRY((((program)->get_scope((current_id.value())))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::Value> _magic = ((((scope)->comptime_bindings)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::Value>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<DeprecatedString,types::Value> pair = (_magic_value.value());
-{
-if (((bindings).contains(((pair).template get<0>())))){
-continue;
-}
-TRY((((bindings).set(((pair).template get<0>()),((pair).template get<1>())))));
-}
-
-}
-}
-
-(current_id = ((scope)->parent));
-}
-return (TRY((interpreter::InterpreterScope::__jakt_create(bindings,parent,(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))),(TRY((DynamicArray<interpreter::Deferred>::create_with({}))))))));
-}
-}
-
-ErrorOr<types::GenericInferences> interpreter::InterpreterScope::type_map_for_substitution() const {
-{
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> map = (TRY((Dictionary<DeprecatedString, DeprecatedString>::create_with_entries({}))));
-TRY((((*this).type_map_for_substitution_helper(((map))))));
-return (types::GenericInferences(map));
-}
-}
-
-interpreter::InterpreterScope::InterpreterScope(JaktInternal::Dictionary<DeprecatedString,types::Value> a_bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> a_parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> a_type_bindings, JaktInternal::DynamicArray<interpreter::Deferred> a_defers): bindings(move(a_bindings)), parent(move(a_parent)), type_bindings(move(a_type_bindings)), defers(move(a_defers)){}
-ErrorOr<NonnullRefPtr<InterpreterScope>> interpreter::InterpreterScope::__jakt_create(JaktInternal::Dictionary<DeprecatedString,types::Value> bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings, JaktInternal::DynamicArray<interpreter::Deferred> defers) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) InterpreterScope (move(bindings), move(parent), move(type_bindings), move(defers)))); return o; }
-ErrorOr<types::TypeId> interpreter::InterpreterScope::map_type(types::TypeId const id) const {
-{
-DeprecatedString const name = TRY((((id).to_string())));
-if (((((*this).type_bindings)).contains(name))){
-return (((((*this).type_bindings))[name]));
-}
-JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> scope = ((*this).parent);
-while (((scope).has_value())){
-if ((((((scope.value()))->type_bindings)).contains(name))){
-return ((((((scope.value()))->type_bindings))[name]));
-}
-(scope = (((scope.value()))->parent));
-}
-return (id);
-}
-}
-
-ErrorOr<void> interpreter::InterpreterScope::set(DeprecatedString const name,types::Value const value) {
-{
-if (((((*this).bindings)).contains(name))){
-TRY(((*this).bindings).set(name, value));
-return {};
-}
-JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> scope = ((*this).parent);
-while (((scope).has_value())){
-if ((((((scope.value()))->bindings)).contains(name))){
-TRY((((scope.value()))->bindings).set(name, value));
-return {};
-}
-(scope = (((scope.value()))->parent));
-}
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::UnknownVariable))));
-}
-return {};
-}
-
-ErrorOr<NonnullRefPtr<interpreter::InterpreterScope>> interpreter::InterpreterScope::create(JaktInternal::Dictionary<DeprecatedString,types::Value> const bindings,JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const parent,JaktInternal::Dictionary<DeprecatedString,types::TypeId> const type_bindings) {
-{
-return (TRY((interpreter::InterpreterScope::__jakt_create(bindings,parent,type_bindings,(TRY((DynamicArray<interpreter::Deferred>::create_with({}))))))));
-}
-}
-
-ErrorOr<void> interpreter::InterpreterScope::type_map_for_substitution_helper(JaktInternal::Dictionary<DeprecatedString,DeprecatedString>& map) const {
-{
-if (((((*this).parent)).has_value())){
-TRY(((((((*this).parent).value()))->type_map_for_substitution_helper(map))));
-}
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::TypeId> _magic = ((((*this).type_bindings)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::TypeId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<DeprecatedString,types::TypeId> pair = (_magic_value.value());
-{
-TRY((((((map))).set(((pair).template get<0>()),TRY((((((pair).template get<1>())).to_string())))))));
-}
-
-}
-}
-
-}
-return {};
-}
-
-ErrorOr<JaktInternal::Dictionary<DeprecatedString,types::Value>> interpreter::InterpreterScope::all_bindings() const {
-{
-JaktInternal::Dictionary<DeprecatedString,types::Value> bindings = (TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({}))));
-JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> scope = static_cast<JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>>>(*this);
-while (((scope).has_value())){
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::Value> _magic = (((((scope.value()))->bindings)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::Value>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<DeprecatedString,types::Value> pair = (_magic_value.value());
-{
-if (((bindings).contains(((pair).template get<0>())))){
-continue;
-}
-TRY((((bindings).set(((pair).template get<0>()),((pair).template get<1>())))));
-}
-
-}
-}
-
-(scope = (((scope.value()))->parent));
-}
-return (bindings);
-}
-}
-
-ErrorOr<types::Value> interpreter::InterpreterScope::must_get(DeprecatedString const name) const {
-{
-if (((((*this).bindings)).contains(name))){
-return (((((*this).bindings))[name]));
-}
-JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> scope = ((*this).parent);
-while (((scope).has_value())){
-if ((((((scope.value()))->bindings)).contains(name))){
-return ((((((scope.value()))->bindings))[name]));
-}
-(scope = (((scope.value()))->parent));
-}
-return Error::from_errno((infallible_integer_cast<i32>((interpreter::InterpretError::UnknownVariable))));
-}
-}
-
-ErrorOr<void> interpreter::InterpreterScope::defer_expression(NonnullRefPtr<typename types::CheckedExpression> const expr) {
-{
-TRY((((((*this).defers)).push( interpreter::Deferred { typename interpreter::Deferred::Expression(expr) } ))));
-}
-return {};
-}
-
-ErrorOr<DeprecatedString> interpreter::StatementResult::debug_description() const {
+ErrorOr<DeprecatedString> interpreter::ExecutionResult::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
 switch (this->index()) {case 0 /* Return */: {
-TRY(builder.append("StatementResult::Return"sv));
-[[maybe_unused]] auto const& that = this->template get<StatementResult::Return>();
+TRY(builder.append("ExecutionResult::Return"sv));
+[[maybe_unused]] auto const& that = this->template get<ExecutionResult::Return>();
 TRY(builder.appendff("({})", that.value));
 break;}
 case 1 /* Throw */: {
-TRY(builder.append("StatementResult::Throw"sv));
-[[maybe_unused]] auto const& that = this->template get<StatementResult::Throw>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 2 /* Yield */: {
-TRY(builder.append("StatementResult::Yield"sv));
-[[maybe_unused]] auto const& that = this->template get<StatementResult::Yield>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 3 /* Continue */: {
-return DeprecatedString("StatementResult::Continue"sv);
-break;}
-case 4 /* Break */: {
-return DeprecatedString("StatementResult::Break"sv);
-break;}
-case 5 /* JustValue */: {
-TRY(builder.append("StatementResult::JustValue"sv));
-[[maybe_unused]] auto const& that = this->template get<StatementResult::JustValue>();
+TRY(builder.append("ExecutionResult::Throw"sv));
+[[maybe_unused]] auto const& that = this->template get<ExecutionResult::Throw>();
 TRY(builder.appendff("({})", that.value));
 break;}
 }
@@ -18448,16 +18432,32 @@ break;}
 }
 return builder.to_string();
 }
-ErrorOr<DeprecatedString> interpreter::ExecutionResult::debug_description() const {
+ErrorOr<DeprecatedString> interpreter::StatementResult::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
 switch (this->index()) {case 0 /* Return */: {
-TRY(builder.append("ExecutionResult::Return"sv));
-[[maybe_unused]] auto const& that = this->template get<ExecutionResult::Return>();
+TRY(builder.append("StatementResult::Return"sv));
+[[maybe_unused]] auto const& that = this->template get<StatementResult::Return>();
 TRY(builder.appendff("({})", that.value));
 break;}
 case 1 /* Throw */: {
-TRY(builder.append("ExecutionResult::Throw"sv));
-[[maybe_unused]] auto const& that = this->template get<ExecutionResult::Throw>();
+TRY(builder.append("StatementResult::Throw"sv));
+[[maybe_unused]] auto const& that = this->template get<StatementResult::Throw>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 2 /* Yield */: {
+TRY(builder.append("StatementResult::Yield"sv));
+[[maybe_unused]] auto const& that = this->template get<StatementResult::Yield>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 3 /* Continue */: {
+return DeprecatedString("StatementResult::Continue"sv);
+break;}
+case 4 /* Break */: {
+return DeprecatedString("StatementResult::Break"sv);
+break;}
+case 5 /* JustValue */: {
+TRY(builder.append("StatementResult::JustValue"sv));
+[[maybe_unused]] auto const& that = this->template get<StatementResult::JustValue>();
 TRY(builder.appendff("({})", that.value));
 break;}
 }
diff --git a/bootstrap/stage0/interpreter.h b/bootstrap/stage0/interpreter.h
index 26160e448..87d9ef8ae 100644
--- a/bootstrap/stage0/interpreter.h
+++ b/bootstrap/stage0/interpreter.h
@@ -8,6 +8,17 @@
 #include "jakt__platform.h"
 namespace Jakt {
 namespace interpreter {
+enum class InterpretError: i32 {
+CallToExternalFunction = (infallible_integer_cast<i32>((static_cast<i32>(42)))),
+MismatchingArguments = (infallible_integer_cast<i32>((static_cast<u64>(43ULL)))),
+InvalidThisArgument = (infallible_integer_cast<i32>((static_cast<u64>(44ULL)))),
+InvalidOperation = (infallible_integer_cast<i32>((static_cast<u64>(45ULL)))),
+InvalidType = (infallible_integer_cast<i32>((static_cast<u64>(46ULL)))),
+UnknownVariable = (infallible_integer_cast<i32>((static_cast<u64>(47ULL)))),
+Unimplemented = (infallible_integer_cast<i32>((static_cast<u64>(48ULL)))),
+UnwrapOptionalNone = (infallible_integer_cast<i32>((static_cast<u64>(49ULL)))),
+InvalidCharacterConstant = (infallible_integer_cast<i32>((static_cast<u64>(50ULL)))),
+};
 namespace StatementResult_Details {
 struct Return{
 types::Value value;
@@ -52,37 +63,6 @@ using Variant<StatementResult_Details::Return, StatementResult_Details::Throw, S
     using JustValue = StatementResult_Details::JustValue;
 ErrorOr<DeprecatedString> debug_description() const;
 };
-class InterpreterScope : public RefCounted<InterpreterScope>, public Weakable<InterpreterScope> {
-  public:
-virtual ~InterpreterScope() = default;
-JaktInternal::Dictionary<DeprecatedString,types::Value> bindings;JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> parent;JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings;JaktInternal::DynamicArray<interpreter::Deferred> defers;ErrorOr<void> defer_statement(NonnullRefPtr<typename types::CheckedStatement> const statement);
-ErrorOr<void> perform_defers(NonnullRefPtr<interpreter::Interpreter> interpreter, utility::Span const span);
-static ErrorOr<NonnullRefPtr<interpreter::InterpreterScope>> from_runtime_scope(types::ScopeId const scope_id, NonnullRefPtr<types::CheckedProgram> const program, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const parent);
-ErrorOr<types::GenericInferences> type_map_for_substitution() const;
-protected:
-explicit InterpreterScope(JaktInternal::Dictionary<DeprecatedString,types::Value> a_bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> a_parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> a_type_bindings, JaktInternal::DynamicArray<interpreter::Deferred> a_defers);
-public:
-static ErrorOr<NonnullRefPtr<InterpreterScope>> __jakt_create(JaktInternal::Dictionary<DeprecatedString,types::Value> bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings, JaktInternal::DynamicArray<interpreter::Deferred> defers);
-
-ErrorOr<types::TypeId> map_type(types::TypeId const id) const;
-ErrorOr<void> set(DeprecatedString const name, types::Value const value);
-static ErrorOr<NonnullRefPtr<interpreter::InterpreterScope>> create(JaktInternal::Dictionary<DeprecatedString,types::Value> const bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> const type_bindings);
-ErrorOr<void> type_map_for_substitution_helper(JaktInternal::Dictionary<DeprecatedString,DeprecatedString>& map) const;
-ErrorOr<JaktInternal::Dictionary<DeprecatedString,types::Value>> all_bindings() const;
-ErrorOr<types::Value> must_get(DeprecatedString const name) const;
-ErrorOr<void> defer_expression(NonnullRefPtr<typename types::CheckedExpression> const expr);
-ErrorOr<DeprecatedString> debug_description() const;
-};enum class InterpretError: i32 {
-CallToExternalFunction = (infallible_integer_cast<i32>((static_cast<i32>(42)))),
-MismatchingArguments = (infallible_integer_cast<i32>((static_cast<u64>(43ULL)))),
-InvalidThisArgument = (infallible_integer_cast<i32>((static_cast<u64>(44ULL)))),
-InvalidOperation = (infallible_integer_cast<i32>((static_cast<u64>(45ULL)))),
-InvalidType = (infallible_integer_cast<i32>((static_cast<u64>(46ULL)))),
-UnknownVariable = (infallible_integer_cast<i32>((static_cast<u64>(47ULL)))),
-Unimplemented = (infallible_integer_cast<i32>((static_cast<u64>(48ULL)))),
-UnwrapOptionalNone = (infallible_integer_cast<i32>((static_cast<u64>(49ULL)))),
-InvalidCharacterConstant = (infallible_integer_cast<i32>((static_cast<u64>(50ULL)))),
-};
 namespace ExecutionResult_Details {
 struct Return{
 types::Value value;
@@ -108,42 +88,62 @@ ErrorOr<DeprecatedString> debug_description() const;
 class Interpreter : public RefCounted<Interpreter>, public Weakable<Interpreter> {
   public:
 virtual ~Interpreter() = default;
-NonnullRefPtr<compiler::Compiler> compiler;NonnullRefPtr<types::CheckedProgram> program;JaktInternal::DynamicArray<utility::Span> spans;JaktInternal::Dictionary<DeprecatedString,types::Value> reflected_type_cache;JaktInternal::Set<DeprecatedString> seen_reflected_types;JaktInternal::Optional<types::FunctionId> current_function_id;NonnullRefPtr<types::TypecheckFunctions> typecheck_functions;ErrorOr<void> update_binding(NonnullRefPtr<typename types::CheckedExpression> const binding, NonnullRefPtr<interpreter::InterpreterScope> scope, types::Value const value, utility::Span const span);
+NonnullRefPtr<compiler::Compiler> compiler;NonnullRefPtr<types::CheckedProgram> program;JaktInternal::DynamicArray<utility::Span> spans;JaktInternal::Dictionary<DeprecatedString,types::Value> reflected_type_cache;JaktInternal::Set<DeprecatedString> seen_reflected_types;JaktInternal::Optional<types::FunctionId> current_function_id;NonnullRefPtr<types::TypecheckFunctions> typecheck_functions;ErrorOr<interpreter::ExecutionResult> execute(types::FunctionId const function_to_run_id, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> namespace_, JaktInternal::Optional<types::Value> const this_argument, JaktInternal::DynamicArray<types::Value> const arguments, utility::Span const call_span, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const invocation_scope);
+ErrorOr<types::Value> tuple_value(JaktInternal::DynamicArray<types::Value> const members, types::TypeId const type, utility::Span const span);
+static ErrorOr<NonnullRefPtr<interpreter::Interpreter>> create(NonnullRefPtr<compiler::Compiler> const compiler, NonnullRefPtr<types::CheckedProgram> const program, NonnullRefPtr<types::TypecheckFunctions> const typecheck_functions, JaktInternal::DynamicArray<utility::Span> const spans);
+void leave_span();
+ErrorOr<void> enter_span(utility::Span const span);
+ErrorOr<types::TypeId> tuple_type(JaktInternal::DynamicArray<types::TypeId> const members);
+ErrorOr<bool> get_prelude_function(types::ScopeId const scope_id) const;
+ErrorOr<types::TypeId> find_or_add_type_id(NonnullRefPtr<typename types::Type> const type);
+ErrorOr<types::CheckedBlock> perform_final_interpretation_pass(types::CheckedBlock const block, JaktInternal::Optional<types::ScopeId> const runtime_scope, NonnullRefPtr<interpreter::InterpreterScope> const scope);
+ErrorOr<types::CheckedBlock> perform_final_interpretation_pass(parser::ParsedBlock const block, types::ScopeId const runtime_scope, NonnullRefPtr<interpreter::InterpreterScope> const scope);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> perform_final_interpretation_pass(NonnullRefPtr<typename types::CheckedStatement> const statement, NonnullRefPtr<interpreter::InterpreterScope> const scope);
+ErrorOr<types::Value> reflect_methods(utility::Span const span);
+ErrorOr<interpreter::StatementResult> execute_binary_operator(types::Value const lhs_value, types::Value const rhs_value, parser::BinaryOperator const op, utility::Span const span, NonnullRefPtr<interpreter::InterpreterScope> const scope);
+ErrorOr<types::Value> array_value_of_type(JaktInternal::DynamicArray<types::Value> const values, types::TypeId const type, utility::Span const span);
+ErrorOr<void> error_with_hint(DeprecatedString const message, utility::Span const span, DeprecatedString const hint_message, utility::Span const hint_span);
+ErrorOr<types::TypeId> array_type_of_struct(types::StructId const struct_id);
+ErrorOr<interpreter::StatementResult> call_prelude_function(DeprecatedString const prelude_function, JaktInternal::DynamicArray<types::ResolvedNamespace> const namespace_, JaktInternal::Optional<types::Value> const this_argument, JaktInternal::DynamicArray<types::Value> const arguments, utility::Span const call_span, JaktInternal::Dictionary<DeprecatedString,types::TypeId> const type_bindings);
 protected:
 explicit Interpreter(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, JaktInternal::DynamicArray<utility::Span> a_spans, JaktInternal::Dictionary<DeprecatedString,types::Value> a_reflected_type_cache, JaktInternal::Set<DeprecatedString> a_seen_reflected_types, JaktInternal::Optional<types::FunctionId> a_current_function_id, NonnullRefPtr<types::TypecheckFunctions> a_typecheck_functions);
 public:
 static ErrorOr<NonnullRefPtr<Interpreter>> __jakt_create(NonnullRefPtr<compiler::Compiler> compiler, NonnullRefPtr<types::CheckedProgram> program, JaktInternal::DynamicArray<utility::Span> spans, JaktInternal::Dictionary<DeprecatedString,types::Value> reflected_type_cache, JaktInternal::Set<DeprecatedString> seen_reflected_types, JaktInternal::Optional<types::FunctionId> current_function_id, NonnullRefPtr<types::TypecheckFunctions> typecheck_functions);
 
 ErrorOr<types::CheckedBlock> typecheck_block(parser::ParsedBlock const block, types::ScopeId const scope);
-ErrorOr<types::Value> reflect_methods(utility::Span const span);
-ErrorOr<types::Value> string_value(DeprecatedString const string, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> perform_final_interpretation_expr_pass(NonnullRefPtr<typename types::CheckedExpression> const expr, NonnullRefPtr<interpreter::InterpreterScope> const scope);
-ErrorOr<types::CheckedBlock> perform_final_interpretation_pass(types::CheckedBlock const block, JaktInternal::Optional<types::ScopeId> const runtime_scope, NonnullRefPtr<interpreter::InterpreterScope> const scope);
-ErrorOr<types::CheckedBlock> perform_final_interpretation_pass(parser::ParsedBlock const block, types::ScopeId const runtime_scope, NonnullRefPtr<interpreter::InterpreterScope> const scope);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> perform_final_interpretation_pass(NonnullRefPtr<typename types::CheckedStatement> const statement, NonnullRefPtr<interpreter::InterpreterScope> const scope);
 ErrorOr<JaktInternal::DynamicArray<types::Value>> reflect_sum_enum_variants(types::CheckedEnum const subject_enum, utility::Span const span, NonnullRefPtr<interpreter::InterpreterScope> const scope);
-ErrorOr<types::Value> array_value_of_type(JaktInternal::DynamicArray<types::Value> const values, types::TypeId const type, utility::Span const span);
-ErrorOr<void> error_with_hint(DeprecatedString const message, utility::Span const span, DeprecatedString const hint_message, utility::Span const hint_span);
-ErrorOr<interpreter::StatementResult> call_prelude_function(DeprecatedString const prelude_function, JaktInternal::DynamicArray<types::ResolvedNamespace> const namespace_, JaktInternal::Optional<types::Value> const this_argument, JaktInternal::DynamicArray<types::Value> const arguments, utility::Span const call_span, JaktInternal::Dictionary<DeprecatedString,types::TypeId> const type_bindings);
-ErrorOr<void> enter_span(utility::Span const span);
-ErrorOr<bool> get_prelude_function(types::ScopeId const scope_id) const;
-ErrorOr<interpreter::StatementResult> execute_expression(NonnullRefPtr<typename types::CheckedExpression> const expr, NonnullRefPtr<interpreter::InterpreterScope> scope);
-ErrorOr<types::Value> tuple_value(JaktInternal::DynamicArray<types::Value> const members, types::TypeId const type, utility::Span const span);
+ErrorOr<interpreter::StatementResult> execute_statement(NonnullRefPtr<typename types::CheckedStatement> const statement, NonnullRefPtr<interpreter::InterpreterScope> scope, utility::Span const call_span);
+ErrorOr<void> update_binding(NonnullRefPtr<typename types::CheckedExpression> const binding, NonnullRefPtr<interpreter::InterpreterScope> scope, types::Value const value, utility::Span const span);
 ErrorOr<JaktInternal::DynamicArray<types::Value>> reflect_fields(JaktInternal::DynamicArray<types::VarId> const fields, utility::Span const span, NonnullRefPtr<interpreter::InterpreterScope> const scope);
-ErrorOr<interpreter::StatementResult> execute_binary_operator(types::Value const lhs_value, types::Value const rhs_value, parser::BinaryOperator const op, utility::Span const span, NonnullRefPtr<interpreter::InterpreterScope> const scope);
-ErrorOr<types::TypeId> array_type_of_struct(types::StructId const struct_id);
-ErrorOr<types::TypeId> find_or_add_type_id(NonnullRefPtr<typename types::Type> const type);
-void leave_span();
 ErrorOr<void> error(DeprecatedString const message, utility::Span const span);
-static ErrorOr<NonnullRefPtr<interpreter::Interpreter>> create(NonnullRefPtr<compiler::Compiler> const compiler, NonnullRefPtr<types::CheckedProgram> const program, NonnullRefPtr<types::TypecheckFunctions> const typecheck_functions, JaktInternal::DynamicArray<utility::Span> const spans);
+ErrorOr<types::Value> string_value(DeprecatedString const string, utility::Span const span);
 ErrorOr<interpreter::StatementResult> execute_expression_without_cast(NonnullRefPtr<typename types::CheckedExpression> const expr, NonnullRefPtr<interpreter::InterpreterScope> scope);
-ErrorOr<interpreter::StatementResult> execute_statement(NonnullRefPtr<typename types::CheckedStatement> const statement, NonnullRefPtr<interpreter::InterpreterScope> scope, utility::Span const call_span);
-ErrorOr<interpreter::ExecutionResult> execute(types::FunctionId const function_to_run_id, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> namespace_, JaktInternal::Optional<types::Value> const this_argument, JaktInternal::DynamicArray<types::Value> const arguments, utility::Span const call_span, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const invocation_scope);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> perform_final_interpretation_expr_pass(NonnullRefPtr<typename types::CheckedExpression> const expr, NonnullRefPtr<interpreter::InterpreterScope> const scope);
+ErrorOr<interpreter::StatementResult> execute_expression(NonnullRefPtr<typename types::CheckedExpression> const expr, NonnullRefPtr<interpreter::InterpreterScope> scope);
 static ErrorOr<types::CheckedBlock> invoke_typecheck_block(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> const& function, parser::ParsedBlock const block, types::ScopeId const parent_scope_id);
-ErrorOr<types::TypeId> tuple_type(JaktInternal::DynamicArray<types::TypeId> const members);
 ErrorOr<interpreter::StatementResult> execute_block(types::CheckedBlock const block, NonnullRefPtr<interpreter::InterpreterScope> scope, utility::Span const call_span);
 ErrorOr<types::Value> reflect_type(types::TypeId const type_id, utility::Span const span, NonnullRefPtr<interpreter::InterpreterScope> const scope);
 ErrorOr<DeprecatedString> debug_description() const;
+};class InterpreterScope : public RefCounted<InterpreterScope>, public Weakable<InterpreterScope> {
+  public:
+virtual ~InterpreterScope() = default;
+JaktInternal::Dictionary<DeprecatedString,types::Value> bindings;JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> parent;JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings;JaktInternal::DynamicArray<interpreter::Deferred> defers;ErrorOr<void> set(DeprecatedString const name, types::Value const value);
+static ErrorOr<NonnullRefPtr<interpreter::InterpreterScope>> create(JaktInternal::Dictionary<DeprecatedString,types::Value> const bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> const type_bindings);
+ErrorOr<void> defer_statement(NonnullRefPtr<typename types::CheckedStatement> const statement);
+ErrorOr<void> perform_defers(NonnullRefPtr<interpreter::Interpreter> interpreter, utility::Span const span);
+static ErrorOr<NonnullRefPtr<interpreter::InterpreterScope>> from_runtime_scope(types::ScopeId const scope_id, NonnullRefPtr<types::CheckedProgram> const program, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> const parent);
+ErrorOr<JaktInternal::Dictionary<DeprecatedString,types::Value>> all_bindings() const;
+ErrorOr<void> type_map_for_substitution_helper(JaktInternal::Dictionary<DeprecatedString,DeprecatedString>& map) const;
+ErrorOr<types::GenericInferences> type_map_for_substitution() const;
+protected:
+explicit InterpreterScope(JaktInternal::Dictionary<DeprecatedString,types::Value> a_bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> a_parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> a_type_bindings, JaktInternal::DynamicArray<interpreter::Deferred> a_defers);
+public:
+static ErrorOr<NonnullRefPtr<InterpreterScope>> __jakt_create(JaktInternal::Dictionary<DeprecatedString,types::Value> bindings, JaktInternal::Optional<NonnullRefPtr<interpreter::InterpreterScope>> parent, JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings, JaktInternal::DynamicArray<interpreter::Deferred> defers);
+
+ErrorOr<void> defer_expression(NonnullRefPtr<typename types::CheckedExpression> const expr);
+ErrorOr<types::Value> must_get(DeprecatedString const name) const;
+ErrorOr<types::TypeId> map_type(types::TypeId const id) const;
+ErrorOr<DeprecatedString> debug_description() const;
 };namespace Deferred_Details {
 struct Expression{
 NonnullRefPtr<typename types::CheckedExpression> value;
@@ -174,12 +174,6 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::interpreter::InterpreterScope> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::interpreter::InterpreterScope const& value) {
-JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
-};
-namespace Jakt {
-} // namespace Jakt
 template<>struct Jakt::Formatter<Jakt::interpreter::ExecutionResult> : Jakt::Formatter<Jakt::StringView>{
 Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::interpreter::ExecutionResult const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
@@ -192,6 +186,12 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
+template<>struct Jakt::Formatter<Jakt::interpreter::InterpreterScope> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::interpreter::InterpreterScope const& value) {
+JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
+};
+namespace Jakt {
+} // namespace Jakt
 template<>struct Jakt::Formatter<Jakt::interpreter::Deferred> : Jakt::Formatter<Jakt::StringView>{
 Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::interpreter::Deferred const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
diff --git a/bootstrap/stage0/jakt__arguments.cpp b/bootstrap/stage0/jakt__arguments.cpp
index 855250b2f..7100c4851 100644
--- a/bootstrap/stage0/jakt__arguments.cpp
+++ b/bootstrap/stage0/jakt__arguments.cpp
@@ -85,8 +85,9 @@ return (result);
 }
 }
 
-ErrorOr<bool> jakt__arguments::ArgsParser::flag(JaktInternal::DynamicArray<DeprecatedString> const names) {
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> jakt__arguments::ArgsParser::remaining_arguments() const {
 {
+JaktInternal::DynamicArray<DeprecatedString> remaining = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
 JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((*this).args)).size()))});
 for (;;){
@@ -96,38 +97,35 @@ break;
 }
 size_t i = (_magic_value.value());
 {
+if ((!(((((*this).removed_indices)).contains(i))))){
+TRY((((remaining).push(((((*this).args))[i])))));
+}
+}
+
+}
+}
+
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((names).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((*this).definitely_positional_args)).iterator());
 for (;;){
 JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString name = (_magic_value.value());
+DeprecatedString arg = (_magic_value.value());
 {
-if ((((((*this).args))[i]) == name)){
-TRY((((((*this).removed_indices)).push(i))));
-return (true);
-}
-}
-
-}
-}
-
+TRY((((remaining).push(arg))));
 }
 
 }
 }
 
-return (false);
+return (remaining);
 }
 }
 
-jakt__arguments::ArgsParser::ArgsParser(JaktInternal::DynamicArray<DeprecatedString> a_args, JaktInternal::DynamicArray<size_t> a_removed_indices, JaktInternal::DynamicArray<DeprecatedString> a_definitely_positional_args) :args(move(a_args)), removed_indices(move(a_removed_indices)), definitely_positional_args(move(a_definitely_positional_args)){}
-
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> jakt__arguments::ArgsParser::remaining_arguments() const {
+ErrorOr<bool> jakt__arguments::ArgsParser::flag(JaktInternal::DynamicArray<DeprecatedString> const names) {
 {
-JaktInternal::DynamicArray<DeprecatedString> remaining = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
 JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((*this).args)).size()))});
 for (;;){
@@ -137,30 +135,30 @@ break;
 }
 size_t i = (_magic_value.value());
 {
-if ((!(((((*this).removed_indices)).contains(i))))){
-TRY((((remaining).push(((((*this).args))[i])))));
-}
-}
-
-}
-}
-
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((*this).definitely_positional_args)).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((names).iterator());
 for (;;){
 JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString arg = (_magic_value.value());
+DeprecatedString name = (_magic_value.value());
 {
-TRY((((remaining).push(arg))));
+if ((((((*this).args))[i]) == name)){
+TRY((((((*this).removed_indices)).push(i))));
+return (true);
+}
 }
 
 }
 }
 
-return (remaining);
+}
+
+}
+}
+
+return (false);
 }
 }
 
@@ -211,5 +209,7 @@ return (JaktInternal::OptionalNone());
 }
 }
 
+jakt__arguments::ArgsParser::ArgsParser(JaktInternal::DynamicArray<DeprecatedString> a_args, JaktInternal::DynamicArray<size_t> a_removed_indices, JaktInternal::DynamicArray<DeprecatedString> a_definitely_positional_args) :args(move(a_args)), removed_indices(move(a_removed_indices)), definitely_positional_args(move(a_definitely_positional_args)){}
+
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/jakt__arguments.h b/bootstrap/stage0/jakt__arguments.h
index e6557cf57..8e6785ea2 100644
--- a/bootstrap/stage0/jakt__arguments.h
+++ b/bootstrap/stage0/jakt__arguments.h
@@ -6,11 +6,11 @@ struct ArgsParser {
   public:
 JaktInternal::DynamicArray<DeprecatedString> args;JaktInternal::DynamicArray<size_t> removed_indices;JaktInternal::DynamicArray<DeprecatedString> definitely_positional_args;static ErrorOr<jakt__arguments::ArgsParser> from_args(JaktInternal::DynamicArray<DeprecatedString> const args);
 ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> option_multiple(JaktInternal::DynamicArray<DeprecatedString> const names);
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> remaining_arguments() const;
 ErrorOr<bool> flag(JaktInternal::DynamicArray<DeprecatedString> const names);
+ErrorOr<JaktInternal::Optional<DeprecatedString>> option(JaktInternal::DynamicArray<DeprecatedString> const names);
 ArgsParser(JaktInternal::DynamicArray<DeprecatedString> a_args, JaktInternal::DynamicArray<size_t> a_removed_indices, JaktInternal::DynamicArray<DeprecatedString> a_definitely_positional_args);
 
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> remaining_arguments() const;
-ErrorOr<JaktInternal::Optional<DeprecatedString>> option(JaktInternal::DynamicArray<DeprecatedString> const names);
 ErrorOr<DeprecatedString> debug_description() const;
 };}
 } // namespace Jakt
diff --git a/bootstrap/stage0/jakt__file_iterator.cpp b/bootstrap/stage0/jakt__file_iterator.cpp
index 9bf41fc3f..c14f3b3da 100644
--- a/bootstrap/stage0/jakt__file_iterator.cpp
+++ b/bootstrap/stage0/jakt__file_iterator.cpp
@@ -14,8 +14,6 @@ return (TRY((jakt__file_iterator::RecursiveFileIterator::__jakt_create(extension
 }
 }
 
-jakt__file_iterator::RecursiveFileIterator::RecursiveFileIterator(DeprecatedString a_extension, JaktInternal::DynamicArray<jakt__path::Path> a_directory_list, JaktInternal::Optional<NonnullRefPtr<jakt__platform__unknown_fs::DirectoryIterator>> a_current_directory): extension(move(a_extension)), directory_list(move(a_directory_list)), current_directory(move(a_current_directory)){}
-ErrorOr<NonnullRefPtr<RecursiveFileIterator>> jakt__file_iterator::RecursiveFileIterator::__jakt_create(DeprecatedString extension, JaktInternal::DynamicArray<jakt__path::Path> directory_list, JaktInternal::Optional<NonnullRefPtr<jakt__platform__unknown_fs::DirectoryIterator>> current_directory) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) RecursiveFileIterator (move(extension), move(directory_list), move(current_directory)))); return o; }
 ErrorOr<JaktInternal::Optional<jakt__path::Path>> jakt__file_iterator::RecursiveFileIterator::next() {
 {
 if ((!(((((*this).current_directory)).has_value())))){
@@ -54,5 +52,7 @@ return (JaktInternal::OptionalNone());
 }
 }
 
+jakt__file_iterator::RecursiveFileIterator::RecursiveFileIterator(DeprecatedString a_extension, JaktInternal::DynamicArray<jakt__path::Path> a_directory_list, JaktInternal::Optional<NonnullRefPtr<jakt__platform__unknown_fs::DirectoryIterator>> a_current_directory): extension(move(a_extension)), directory_list(move(a_directory_list)), current_directory(move(a_current_directory)){}
+ErrorOr<NonnullRefPtr<RecursiveFileIterator>> jakt__file_iterator::RecursiveFileIterator::__jakt_create(DeprecatedString extension, JaktInternal::DynamicArray<jakt__path::Path> directory_list, JaktInternal::Optional<NonnullRefPtr<jakt__platform__unknown_fs::DirectoryIterator>> current_directory) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) RecursiveFileIterator (move(extension), move(directory_list), move(current_directory)))); return o; }
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/jakt__file_iterator.h b/bootstrap/stage0/jakt__file_iterator.h
index 6a7e2fe54..9c2f5927c 100644
--- a/bootstrap/stage0/jakt__file_iterator.h
+++ b/bootstrap/stage0/jakt__file_iterator.h
@@ -9,12 +9,12 @@ class RecursiveFileIterator : public RefCounted<RecursiveFileIterator>, public W
   public:
 virtual ~RecursiveFileIterator() = default;
 DeprecatedString extension;JaktInternal::DynamicArray<jakt__path::Path> directory_list;JaktInternal::Optional<NonnullRefPtr<jakt__platform__unknown_fs::DirectoryIterator>> current_directory;static ErrorOr<NonnullRefPtr<jakt__file_iterator::RecursiveFileIterator>> make(jakt__path::Path const directory, DeprecatedString const extension);
+ErrorOr<JaktInternal::Optional<jakt__path::Path>> next();
 protected:
 explicit RecursiveFileIterator(DeprecatedString a_extension, JaktInternal::DynamicArray<jakt__path::Path> a_directory_list, JaktInternal::Optional<NonnullRefPtr<jakt__platform__unknown_fs::DirectoryIterator>> a_current_directory);
 public:
 static ErrorOr<NonnullRefPtr<RecursiveFileIterator>> __jakt_create(DeprecatedString extension, JaktInternal::DynamicArray<jakt__path::Path> directory_list, JaktInternal::Optional<NonnullRefPtr<jakt__platform__unknown_fs::DirectoryIterator>> current_directory);
 
-ErrorOr<JaktInternal::Optional<jakt__path::Path>> next();
 ErrorOr<DeprecatedString> debug_description() const;
 };}
 } // namespace Jakt
diff --git a/bootstrap/stage0/jakt__path.cpp b/bootstrap/stage0/jakt__path.cpp
index ae1d80071..fc3af4787 100644
--- a/bootstrap/stage0/jakt__path.cpp
+++ b/bootstrap/stage0/jakt__path.cpp
@@ -6,25 +6,98 @@ JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("path: \"{}\"", path));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<jakt__path::Path> jakt__path::Path::from_parts(JaktInternal::DynamicArray<DeprecatedString> const parts) {
+ErrorOr<DeprecatedString> jakt__path::Path::extension() const {
 {
-jakt__path::Path path = jakt__path::Path(Jakt::DeprecatedString("."sv));
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((parts).iterator());
+JaktInternal::Range<size_t> _magic = (((JaktInternal::Range<size_t>{static_cast<size_t>((JaktInternal::checked_sub<size_t>(((((*this).path)).length()),static_cast<size_t>(1ULL)))),static_cast<size_t>(static_cast<size_t>(0ULL))})).inclusive());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString part = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-(path = TRY((((path).join(part)))));
+u8 const c = ((((*this).path)).byte_at(i));
+if ((c == static_cast<u8>(47))){
+break;
+}
+if ((c == '.')){
+return (((((*this).path)).substring((JaktInternal::checked_add<size_t>(i,static_cast<size_t>(1ULL))),(JaktInternal::checked_sub<size_t>((JaktInternal::checked_sub<size_t>(((((*this).path)).length()),static_cast<size_t>(1ULL))),i)))));
+}
 }
 
 }
 }
 
-return (path);
+return (Jakt::DeprecatedString(""sv));
+}
+}
+
+jakt__path::Path::Path(DeprecatedString a_path) :path(move(a_path)){}
+
+ErrorOr<DeprecatedString> jakt__path::Path::basename(bool const strip_extension) const {
+{
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> const parts = TRY((((*this).split_at_last_slash())));
+if (strip_extension){
+size_t ext_length = ((TRY((((*this).extension())))).length());
+if ((ext_length > static_cast<size_t>(0ULL))){
+({auto& _jakt_ref = ext_length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+}
+return (((((parts).template get<1>())).substring(static_cast<size_t>(0ULL),(JaktInternal::checked_sub<size_t>(((((parts).template get<1>())).length()),ext_length)))));
+}
+return (((parts).template get<1>()));
+}
+}
+
+ErrorOr<jakt__path::Path> jakt__path::Path::join(DeprecatedString const path) const {
+{
+if (((((*this).path) == Jakt::DeprecatedString("."sv)) || (((((*this).path)).length()) == static_cast<size_t>(0ULL)))){
+return (jakt__path::Path(path));
+}
+if (((path).is_empty())){
+return (*this);
+}
+u8 const separator = static_cast<u8>(47);
+if ((((path).byte_at(static_cast<size_t>(0ULL))) == separator)){
+return (TRY((jakt__path::Path::from_string(path))));
+}
+DeprecatedStringBuilder join_builder = TRY((DeprecatedStringBuilder::create()));
+TRY((((join_builder).append_string(((*this).path)))));
+if ((((((*this).path)).byte_at((JaktInternal::checked_sub<size_t>(((((*this).path)).length()),static_cast<size_t>(1ULL))))) != separator)){
+TRY((((join_builder).append(separator))));
+}
+TRY((((join_builder).append_string(path))));
+return (TRY((jakt__path::Path::from_string(TRY((((join_builder).to_string())))))));
+}
+}
+
+DeprecatedString jakt__path::Path::to_string() const {
+{
+return (((*this).path));
+}
+}
+
+bool jakt__path::Path::exists() const {
+{
+return (File::exists(((*this).path)));
+}
+}
+
+ErrorOr<jakt__path::Path> jakt__path::Path::replace_extension(DeprecatedString const new_extension) const {
+{
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> const parts = TRY((((*this).split_at_last_slash())));
+DeprecatedString const basename = TRY((((*this).basename(true))));
+DeprecatedString const extension = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<jakt__path::Path>>{
+auto __jakt_enum_value = (new_extension);
+if (__jakt_enum_value == Jakt::DeprecatedString(""sv)) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
+}
+else {
+return JaktInternal::ExplicitValue((Jakt::DeprecatedString("."sv) + new_extension));
+}
+}()))
+;
+return (TRY((jakt__path::Path::from_parts((TRY((DynamicArray<DeprecatedString>::create_with({((parts).template get<0>()), (basename + extension)}))))))));
 }
 }
 
@@ -42,44 +115,33 @@ return (i);
 }
 }
 
-jakt__path::Path::Path(DeprecatedString a_path) :path(move(a_path)){}
-
-bool jakt__path::Path::is_dot() const {
-{
-return (((((*this).path) == Jakt::DeprecatedString("."sv)) || (((*this).path) == Jakt::DeprecatedString(".."sv))));
-}
-}
-
-DeprecatedString jakt__path::Path::to_string() const {
+ErrorOr<jakt__path::Path> jakt__path::Path::from_string(DeprecatedString const string) {
 {
-return (((*this).path));
+jakt__path::Path path = jakt__path::Path(string);
+TRY((((path).normalize_separators())));
+return (path);
 }
 }
 
-ErrorOr<DeprecatedString> jakt__path::Path::extension() const {
+ErrorOr<jakt__path::Path> jakt__path::Path::from_parts(JaktInternal::DynamicArray<DeprecatedString> const parts) {
 {
+jakt__path::Path path = jakt__path::Path(Jakt::DeprecatedString("."sv));
 {
-JaktInternal::Range<size_t> _magic = (((JaktInternal::Range<size_t>{static_cast<size_t>((JaktInternal::checked_sub<size_t>(((((*this).path)).length()),static_cast<size_t>(1ULL)))),static_cast<size_t>(static_cast<size_t>(0ULL))})).inclusive());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((parts).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+DeprecatedString part = (_magic_value.value());
 {
-u8 const c = ((((*this).path)).byte_at(i));
-if ((c == static_cast<u8>(47))){
-break;
-}
-if ((c == '.')){
-return (((((*this).path)).substring((JaktInternal::checked_add<size_t>(i,static_cast<size_t>(1ULL))),(JaktInternal::checked_sub<size_t>((JaktInternal::checked_sub<size_t>(((((*this).path)).length()),static_cast<size_t>(1ULL))),i)))));
-}
+(path = TRY((((path).join(part)))));
 }
 
 }
 }
 
-return (Jakt::DeprecatedString(""sv));
+return (path);
 }
 }
 
@@ -96,6 +158,16 @@ return ((Tuple{Jakt::DeprecatedString(""sv), ((*this).path)}));
 }
 }
 
+ErrorOr<jakt__path::Path> jakt__path::Path::parent() const {
+{
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> const parts = TRY((((*this).split_at_last_slash())));
+if ((((parts).template get<0>()) == Jakt::DeprecatedString(""sv))){
+return (jakt__path::Path(Jakt::DeprecatedString("."sv)));
+}
+return (jakt__path::Path(((parts).template get<0>())));
+}
+}
+
 ErrorOr<void> jakt__path::Path::normalize_separators() {
 {
 JaktInternal::DynamicArray<u8> separators = (TRY((DynamicArray<u8>::create_with({static_cast<u8>(47)}))));
@@ -128,81 +200,9 @@ TRY((((normalized_builder).append(ch))));
 return {};
 }
 
-ErrorOr<jakt__path::Path> jakt__path::Path::join(DeprecatedString const path) const {
-{
-if (((((*this).path) == Jakt::DeprecatedString("."sv)) || (((((*this).path)).length()) == static_cast<size_t>(0ULL)))){
-return (jakt__path::Path(path));
-}
-if (((path).is_empty())){
-return (*this);
-}
-u8 const separator = static_cast<u8>(47);
-if ((((path).byte_at(static_cast<size_t>(0ULL))) == separator)){
-return (TRY((jakt__path::Path::from_string(path))));
-}
-DeprecatedStringBuilder join_builder = TRY((DeprecatedStringBuilder::create()));
-TRY((((join_builder).append_string(((*this).path)))));
-if ((((((*this).path)).byte_at((JaktInternal::checked_sub<size_t>(((((*this).path)).length()),static_cast<size_t>(1ULL))))) != separator)){
-TRY((((join_builder).append(separator))));
-}
-TRY((((join_builder).append_string(path))));
-return (TRY((jakt__path::Path::from_string(TRY((((join_builder).to_string())))))));
-}
-}
-
-ErrorOr<DeprecatedString> jakt__path::Path::basename(bool const strip_extension) const {
-{
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> const parts = TRY((((*this).split_at_last_slash())));
-if (strip_extension){
-size_t ext_length = ((TRY((((*this).extension())))).length());
-if ((ext_length > static_cast<size_t>(0ULL))){
-({auto& _jakt_ref = ext_length;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
-}
-return (((((parts).template get<1>())).substring(static_cast<size_t>(0ULL),(JaktInternal::checked_sub<size_t>(((((parts).template get<1>())).length()),ext_length)))));
-}
-return (((parts).template get<1>()));
-}
-}
-
-ErrorOr<jakt__path::Path> jakt__path::Path::parent() const {
-{
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> const parts = TRY((((*this).split_at_last_slash())));
-if ((((parts).template get<0>()) == Jakt::DeprecatedString(""sv))){
-return (jakt__path::Path(Jakt::DeprecatedString("."sv)));
-}
-return (jakt__path::Path(((parts).template get<0>())));
-}
-}
-
-ErrorOr<jakt__path::Path> jakt__path::Path::replace_extension(DeprecatedString const new_extension) const {
-{
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> const parts = TRY((((*this).split_at_last_slash())));
-DeprecatedString const basename = TRY((((*this).basename(true))));
-DeprecatedString const extension = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<jakt__path::Path>>{
-auto __jakt_enum_value = (new_extension);
-if (__jakt_enum_value == Jakt::DeprecatedString(""sv)) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString(""sv));
-}
-else {
-return JaktInternal::ExplicitValue((Jakt::DeprecatedString("."sv) + new_extension));
-}
-}()))
-;
-return (TRY((jakt__path::Path::from_parts((TRY((DynamicArray<DeprecatedString>::create_with({((parts).template get<0>()), (basename + extension)}))))))));
-}
-}
-
-bool jakt__path::Path::exists() const {
-{
-return (File::exists(((*this).path)));
-}
-}
-
-ErrorOr<jakt__path::Path> jakt__path::Path::from_string(DeprecatedString const string) {
+bool jakt__path::Path::is_dot() const {
 {
-jakt__path::Path path = jakt__path::Path(string);
-TRY((((path).normalize_separators())));
-return (path);
+return (((((*this).path) == Jakt::DeprecatedString("."sv)) || (((*this).path) == Jakt::DeprecatedString(".."sv))));
 }
 }
 
diff --git a/bootstrap/stage0/jakt__path.h b/bootstrap/stage0/jakt__path.h
index e39d36ab6..150d88196 100644
--- a/bootstrap/stage0/jakt__path.h
+++ b/bootstrap/stage0/jakt__path.h
@@ -6,21 +6,21 @@ namespace Jakt {
 namespace jakt__path {
 struct Path {
   public:
-DeprecatedString path;static ErrorOr<jakt__path::Path> from_parts(JaktInternal::DynamicArray<DeprecatedString> const parts);
-static JaktInternal::Optional<size_t> last_slash(DeprecatedString const path);
+DeprecatedString path;ErrorOr<DeprecatedString> extension() const;
 Path(DeprecatedString a_path);
 
-bool is_dot() const;
-DeprecatedString to_string() const;
-ErrorOr<DeprecatedString> extension() const;
-ErrorOr<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> split_at_last_slash() const;
-ErrorOr<void> normalize_separators();
-ErrorOr<jakt__path::Path> join(DeprecatedString const path) const;
 ErrorOr<DeprecatedString> basename(bool const strip_extension) const;
-ErrorOr<jakt__path::Path> parent() const;
-ErrorOr<jakt__path::Path> replace_extension(DeprecatedString const new_extension) const;
+ErrorOr<jakt__path::Path> join(DeprecatedString const path) const;
+DeprecatedString to_string() const;
 bool exists() const;
+ErrorOr<jakt__path::Path> replace_extension(DeprecatedString const new_extension) const;
+static JaktInternal::Optional<size_t> last_slash(DeprecatedString const path);
 static ErrorOr<jakt__path::Path> from_string(DeprecatedString const string);
+static ErrorOr<jakt__path::Path> from_parts(JaktInternal::DynamicArray<DeprecatedString> const parts);
+ErrorOr<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> split_at_last_slash() const;
+ErrorOr<jakt__path::Path> parent() const;
+ErrorOr<void> normalize_separators();
+bool is_dot() const;
 ErrorOr<DeprecatedString> debug_description() const;
 };}
 } // namespace Jakt
diff --git a/bootstrap/stage0/jakt__platform.cpp b/bootstrap/stage0/jakt__platform.cpp
index 571efd1ac..932e4e6e4 100644
--- a/bootstrap/stage0/jakt__platform.cpp
+++ b/bootstrap/stage0/jakt__platform.cpp
@@ -1,6 +1,19 @@
 #include "jakt__platform.h"
 namespace Jakt {
 namespace jakt__platform {
+JaktInternal::Optional<size_t> last_namespace_separator(DeprecatedString const name) {
+{
+size_t i = (JaktInternal::checked_sub<size_t>(((name).length()),static_cast<size_t>(1ULL)));
+while ((i >= static_cast<size_t>(2ULL))){
+if (((((name).byte_at(i)) == ':') && (((name).byte_at((JaktInternal::checked_sub<size_t>(i,static_cast<size_t>(1ULL))))) == ':'))){
+return ((JaktInternal::checked_add<size_t>(i,static_cast<size_t>(1ULL))));
+}
+((i--));
+}
+return (JaktInternal::OptionalNone());
+}
+}
+
 ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> add_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings,DeprecatedString const prefix,DeprecatedString const suffix) {
 {
 JaktInternal::DynamicArray<DeprecatedString> output = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
@@ -23,19 +36,6 @@ return (output);
 }
 }
 
-JaktInternal::Optional<size_t> last_namespace_separator(DeprecatedString const name) {
-{
-size_t i = (JaktInternal::checked_sub<size_t>(((name).length()),static_cast<size_t>(1ULL)));
-while ((i >= static_cast<size_t>(2ULL))){
-if (((((name).byte_at(i)) == ':') && (((name).byte_at((JaktInternal::checked_sub<size_t>(i,static_cast<size_t>(1ULL))))) == ':'))){
-return ((JaktInternal::checked_add<size_t>(i,static_cast<size_t>(1ULL))));
-}
-((i--));
-}
-return (JaktInternal::OptionalNone());
-}
-}
-
 ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> platform_import_names() {
 {
 jakt__platform::Target const target = TRY((jakt__platform::Target::active()));
@@ -124,6 +124,12 @@ return (jakt__platform::Target(((parts)[static_cast<i64>(0LL)]),((parts)[static_
 }
 }
 
+ErrorOr<size_t> jakt__platform::Target::size_t_alignment() const {
+{
+return (TRY((((*this).size_t_size()))));
+}
+}
+
 ErrorOr<size_t> jakt__platform::Target::size_t_size() const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,ErrorOr<size_t>>{
@@ -144,12 +150,6 @@ return Error::__jakt_from_string_literal((StringView::from_string_literal("size_
 }
 }
 
-ErrorOr<size_t> jakt__platform::Target::size_t_alignment() const {
-{
-return (TRY((((*this).size_t_size()))));
-}
-}
-
 ErrorOr<size_t> jakt__platform::Target::int_size() const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,ErrorOr<size_t>>{
diff --git a/bootstrap/stage0/jakt__platform.h b/bootstrap/stage0/jakt__platform.h
index aa7312a47..b9cb52553 100644
--- a/bootstrap/stage0/jakt__platform.h
+++ b/bootstrap/stage0/jakt__platform.h
@@ -9,8 +9,8 @@ DeprecatedString arch;DeprecatedString platform;DeprecatedString os;DeprecatedSt
 ErrorOr<size_t> int_alignment() const;
 ErrorOr<size_t> pointer_size() const;
 static ErrorOr<jakt__platform::Target> active();
-ErrorOr<size_t> size_t_size() const;
 ErrorOr<size_t> size_t_alignment() const;
+ErrorOr<size_t> size_t_size() const;
 ErrorOr<size_t> int_size() const;
 ErrorOr<size_t> pointer_alignment() const;
 ErrorOr<DeprecatedString> debug_description() const;
diff --git a/bootstrap/stage0/jakt__platform__unknown_fs.cpp b/bootstrap/stage0/jakt__platform__unknown_fs.cpp
index 048009cc6..378123d54 100644
--- a/bootstrap/stage0/jakt__platform__unknown_fs.cpp
+++ b/bootstrap/stage0/jakt__platform__unknown_fs.cpp
@@ -1,19 +1,19 @@
 #include "jakt__platform__unknown_fs.h"
 namespace Jakt {
 namespace jakt__platform__unknown_fs {
-ErrorOr<void> make_directory(DeprecatedString const path) {
+ErrorOr<DeprecatedString> current_directory() {
 {
-warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: make_directory {}"sv),path);
+warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: current_directory"sv));
 return Error::from_errno(static_cast<i32>(38));
 }
-return {};
 }
 
-ErrorOr<DeprecatedString> current_directory() {
+ErrorOr<void> make_directory(DeprecatedString const path) {
 {
-warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: current_directory"sv));
+warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: make_directory {}"sv),path);
 return Error::from_errno(static_cast<i32>(38));
 }
+return {};
 }
 
 ErrorOr<DeprecatedString> jakt__platform__unknown_fs::DirectoryIterator::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("DirectoryIterator("sv));{
diff --git a/bootstrap/stage0/jakt__platform__unknown_process.cpp b/bootstrap/stage0/jakt__platform__unknown_process.cpp
index 76acfe4a0..ed7e196df 100644
--- a/bootstrap/stage0/jakt__platform__unknown_process.cpp
+++ b/bootstrap/stage0/jakt__platform__unknown_process.cpp
@@ -1,13 +1,6 @@
 #include "jakt__platform__unknown_process.h"
 namespace Jakt {
 namespace jakt__platform__unknown_process {
-ErrorOr<jakt__platform__unknown_process::Process> start_background_process(JaktInternal::DynamicArray<DeprecatedString> const args) {
-{
-warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: start_background_process {}"sv),args);
-return Error::from_errno(static_cast<i32>(38));
-}
-}
-
 ErrorOr<JaktInternal::Tuple<JaktInternal::Optional<size_t>,jakt__platform__unknown_process::ExitPollResult>> wait_for_some_set_of_processes_that_at_least_includes(JaktInternal::Dictionary<size_t,jakt__platform__unknown_process::Process> const& processes) {
 {
 warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: wait_for_some_set_of_processes_that_at_least_includes {}"sv),processes);
@@ -22,12 +15,11 @@ return Error::from_errno(static_cast<i32>(38));
 }
 }
 
-ErrorOr<void> forcefully_kill_process(jakt__platform__unknown_process::Process const& process) {
+ErrorOr<jakt__platform__unknown_process::Process> start_background_process(JaktInternal::DynamicArray<DeprecatedString> const args) {
 {
-warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: forcefully_kill_process {}"sv),process);
+warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: start_background_process {}"sv),args);
 return Error::from_errno(static_cast<i32>(38));
 }
-return {};
 }
 
 ErrorOr<JaktInternal::Optional<jakt__platform__unknown_process::ExitPollResult>> poll_process_exit(jakt__platform__unknown_process::Process const& process) {
@@ -37,6 +29,14 @@ return Error::from_errno(static_cast<i32>(38));
 }
 }
 
+ErrorOr<void> forcefully_kill_process(jakt__platform__unknown_process::Process const& process) {
+{
+warnln(Jakt::DeprecatedString("NOT IMPLEMENTED: forcefully_kill_process {}"sv),process);
+return Error::from_errno(static_cast<i32>(38));
+}
+return {};
+}
+
 ErrorOr<DeprecatedString> jakt__platform__unknown_process::Process::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Process("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 }
diff --git a/bootstrap/stage0/lexer.cpp b/bootstrap/stage0/lexer.cpp
index dac976cb9..5763fc89a 100644
--- a/bootstrap/stage0/lexer.cpp
+++ b/bootstrap/stage0/lexer.cpp
@@ -9,6 +9,33 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("comment_contents: {}", comment_contents));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<JaktInternal::Optional<DeprecatedString>> lexer::Lexer::consume_comment_contents() {
+{
+if ((!(((((*this).comment_contents)).has_value())))){
+return (JaktInternal::OptionalNone());
+}
+JaktInternal::DynamicArray<u8> const contents = (((*this).comment_contents).value());
+(((*this).comment_contents) = JaktInternal::OptionalNone());
+DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+{
+JaktInternal::ArrayIterator<u8> _magic = ((contents).iterator());
+for (;;){
+JaktInternal::Optional<u8> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+u8 c = (_magic_value.value());
+{
+TRY((((builder).append(c))));
+}
+
+}
+}
+
+return (TRY((((builder).to_string()))));
+}
+}
+
 ErrorOr<lexer::Token> lexer::Lexer::lex_quoted_string(u8 const delimiter) {
 {
 size_t const start = ((*this).index);
@@ -162,33 +189,6 @@ return JaktInternal::ExplicitValue(TRY((((*this).lex_number_or_name()))));
 }
 }
 
-ErrorOr<JaktInternal::Optional<DeprecatedString>> lexer::Lexer::consume_comment_contents() {
-{
-if ((!(((((*this).comment_contents)).has_value())))){
-return (JaktInternal::OptionalNone());
-}
-JaktInternal::DynamicArray<u8> const contents = (((*this).comment_contents).value());
-(((*this).comment_contents) = JaktInternal::OptionalNone());
-DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
-{
-JaktInternal::ArrayIterator<u8> _magic = ((contents).iterator());
-for (;;){
-JaktInternal::Optional<u8> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-u8 c = (_magic_value.value());
-{
-TRY((((builder).append(c))));
-}
-
-}
-}
-
-return (TRY((((builder).to_string()))));
-}
-}
-
 ErrorOr<lexer::Token> lexer::Lexer::lex_character_constant_or_name() {
 {
 if ((((*this).peek_ahead(static_cast<size_t>(1ULL))) != '\'')){
@@ -256,34 +256,6 @@ return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Dot(((
 }
 }
 
-ErrorOr<lexer::Token> lexer::Lexer::lex_forward_slash() {
-{
-size_t const start = ((((*this).index)++));
-if ((((*this).peek()) == '=')){
-return ( lexer::Token { typename lexer::Token::ForwardSlashEqual(((*this).span(start,(++(((*this).index)))))) } );
-}
-if ((((*this).peek()) != '/')){
-return ( lexer::Token { typename lexer::Token::ForwardSlash(((*this).span(start,((*this).index)))) } );
-}
-if (((((*this).comment_contents)).has_value())){
-((((*this).index)--));
-return ( lexer::Token { typename lexer::Token::Eol(TRY((((*this).consume_comment_contents()))),((*this).span(start,((*this).index)))) } );
-}
-((((*this).index)++));
-size_t const comment_start_index = ((*this).index);
-while ((!(((*this).eof())))){
-u8 const c = ((*this).peek());
-((((*this).index)++));
-if ((c == '\n')){
-((((*this).index)--));
-break;
-}
-}
-(((*this).comment_contents) = TRY((((((((*this).input))[(JaktInternal::Range<size_t>{static_cast<size_t>(comment_start_index),static_cast<size_t>(((*this).index))})])).to_array()))));
-return (TRY((((*this).next()))).value_or_lazy_evaluated([&] { return  lexer::Token { typename lexer::Token::Eof(((*this).span(((*this).index),((*this).index)))) } ; }));
-}
-}
-
 lexer::Token lexer::Lexer::lex_question_mark() {
 {
 size_t const start = ((((*this).index)++));
@@ -314,6 +286,34 @@ return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Questi
 }
 }
 
+ErrorOr<lexer::Token> lexer::Lexer::lex_forward_slash() {
+{
+size_t const start = ((((*this).index)++));
+if ((((*this).peek()) == '=')){
+return ( lexer::Token { typename lexer::Token::ForwardSlashEqual(((*this).span(start,(++(((*this).index)))))) } );
+}
+if ((((*this).peek()) != '/')){
+return ( lexer::Token { typename lexer::Token::ForwardSlash(((*this).span(start,((*this).index)))) } );
+}
+if (((((*this).comment_contents)).has_value())){
+((((*this).index)--));
+return ( lexer::Token { typename lexer::Token::Eol(TRY((((*this).consume_comment_contents()))),((*this).span(start,((*this).index)))) } );
+}
+((((*this).index)++));
+size_t const comment_start_index = ((*this).index);
+while ((!(((*this).eof())))){
+u8 const c = ((*this).peek());
+((((*this).index)++));
+if ((c == '\n')){
+((((*this).index)--));
+break;
+}
+}
+(((*this).comment_contents) = TRY((((((((*this).input))[(JaktInternal::Range<size_t>{static_cast<size_t>(comment_start_index),static_cast<size_t>(((*this).index))})])).to_array()))));
+return (TRY((((*this).next()))).value_or_lazy_evaluated([&] { return  lexer::Token { typename lexer::Token::Eof(((*this).span(((*this).index),((*this).index)))) } ; }));
+}
+}
+
 u8 lexer::Lexer::peek_behind(size_t const steps) const {
 {
 if ((((*this).index) < steps)){
@@ -348,6 +348,28 @@ return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Asteri
 }
 }
 
+lexer::Token lexer::Lexer::lex_minus() {
+{
+size_t const start = ((((*this).index)++));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
+auto __jakt_enum_value = (((*this).peek()));
+if (__jakt_enum_value == '=') {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::MinusEqual(((*this).span(start,(++(((*this).index)))))) } );
+}
+else if (__jakt_enum_value == '-') {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::MinusMinus(((*this).span(start,(++(((*this).index)))))) } );
+}
+else if (__jakt_enum_value == '>') {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Arrow(((*this).span(start,(++(((*this).index)))))) } );
+}
+else {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Minus(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
+}
+}()))
+);
+}
+}
+
 u8 lexer::Lexer::peek() const {
 {
 if (((*this).eof())){
@@ -405,22 +427,36 @@ return ( lexer::Token { typename lexer::Token::Garbage(TRY((__jakt_format(Jakt::
 }
 }
 
-lexer::Token lexer::Lexer::lex_minus() {
+lexer::Token lexer::Lexer::lex_less_than() {
 {
 size_t const start = ((((*this).index)++));
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
 auto __jakt_enum_value = (((*this).peek()));
 if (__jakt_enum_value == '=') {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::MinusEqual(((*this).span(start,(++(((*this).index)))))) } );
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LessThanOrEqual(((*this).span(start,(++(((*this).index)))))) } );
 }
-else if (__jakt_enum_value == '-') {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::MinusMinus(((*this).span(start,(++(((*this).index)))))) } );
+else if (__jakt_enum_value == '<') {
+return JaktInternal::ExplicitValue(({ Optional<lexer::Token> __jakt_var_3; {
+((((*this).index)++));
+__jakt_var_3 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
+auto __jakt_enum_value = (((*this).peek()));
+if (__jakt_enum_value == '<') {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LeftArithmeticShift(((*this).span(start,(++(((*this).index)))))) } );
 }
-else if (__jakt_enum_value == '>') {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Arrow(((*this).span(start,(++(((*this).index)))))) } );
+else if (__jakt_enum_value == '=') {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LeftShiftEqual(((*this).span(start,(++(((*this).index)))))) } );
 }
 else {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Minus(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LeftShift(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
+}
+}()))
+; goto __jakt_label_1;
+
+}
+__jakt_label_1:; __jakt_var_3.release_value(); }));
+}
+else {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LessThan(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
 }
 }()))
 );
@@ -433,6 +469,8 @@ return ((((*this).index) >= ((((*this).input)).size())));
 }
 }
 
+lexer::Lexer::Lexer(size_t a_index, JaktInternal::DynamicArray<u8> a_input, NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::Optional<JaktInternal::DynamicArray<u8>> a_comment_contents) :index(move(a_index)), input(move(a_input)), compiler(move(a_compiler)), comment_contents(move(a_comment_contents)){}
+
 lexer::Token lexer::Lexer::lex_ampersand() {
 {
 size_t const start = ((((*this).index)++));
@@ -623,8 +661,6 @@ return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Colon(
 }
 }
 
-lexer::Lexer::Lexer(size_t a_index, JaktInternal::DynamicArray<u8> a_input, NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::Optional<JaktInternal::DynamicArray<u8>> a_comment_contents) :index(move(a_index)), input(move(a_input)), compiler(move(a_compiler)), comment_contents(move(a_comment_contents)){}
-
 bool lexer::Lexer::valid_digit(lexer::LiteralPrefix const prefix,u8 const digit,bool const decimal_allowed) {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
@@ -655,6 +691,25 @@ TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::
 return {};
 }
 
+lexer::Token lexer::Lexer::lex_equals() {
+{
+size_t const start = ((((*this).index)++));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
+auto __jakt_enum_value = (((*this).peek()));
+if (__jakt_enum_value == '=') {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::DoubleEqual(((*this).span(start,(++(((*this).index)))))) } );
+}
+else if (__jakt_enum_value == '>') {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::FatArrow(((*this).span(start,(++(((*this).index)))))) } );
+}
+else {
+return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Equal(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
+}
+}()))
+);
+}
+}
+
 ErrorOr<DeprecatedString> lexer::Lexer::substring(size_t const start,size_t const length) const {
 {
 DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
@@ -686,9 +741,9 @@ if (__jakt_enum_value == '=') {
 return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::GreaterThanOrEqual(((*this).span(start,(++(((*this).index)))))) } );
 }
 else if (__jakt_enum_value == '>') {
-return JaktInternal::ExplicitValue(({ Optional<lexer::Token> __jakt_var_3; {
+return JaktInternal::ExplicitValue(({ Optional<lexer::Token> __jakt_var_4; {
 ((((*this).index)++));
-__jakt_var_3 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
+__jakt_var_4 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
 auto __jakt_enum_value = (((*this).peek()));
 if (__jakt_enum_value == '>') {
 return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::RightArithmeticShift(((*this).span(start,(++(((*this).index)))))) } );
@@ -700,10 +755,10 @@ else {
 return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::RightShift(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
 }
 }()))
-; goto __jakt_label_1;
+; goto __jakt_label_2;
 
 }
-__jakt_label_1:; __jakt_var_3.release_value(); }));
+__jakt_label_2:; __jakt_var_4.release_value(); }));
 }
 else {
 return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::GreaterThan(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
@@ -819,61 +874,6 @@ return ( lexer::Token { typename lexer::Token::Number(prefix,TRY((((number).to_s
 }
 }
 
-lexer::Token lexer::Lexer::lex_less_than() {
-{
-size_t const start = ((((*this).index)++));
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
-auto __jakt_enum_value = (((*this).peek()));
-if (__jakt_enum_value == '=') {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LessThanOrEqual(((*this).span(start,(++(((*this).index)))))) } );
-}
-else if (__jakt_enum_value == '<') {
-return JaktInternal::ExplicitValue(({ Optional<lexer::Token> __jakt_var_4; {
-((((*this).index)++));
-__jakt_var_4 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
-auto __jakt_enum_value = (((*this).peek()));
-if (__jakt_enum_value == '<') {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LeftArithmeticShift(((*this).span(start,(++(((*this).index)))))) } );
-}
-else if (__jakt_enum_value == '=') {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LeftShiftEqual(((*this).span(start,(++(((*this).index)))))) } );
-}
-else {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LeftShift(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
-}
-}()))
-; goto __jakt_label_2;
-
-}
-__jakt_label_2:; __jakt_var_4.release_value(); }));
-}
-else {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::LessThan(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
-}
-}()))
-);
-}
-}
-
-lexer::Token lexer::Lexer::lex_equals() {
-{
-size_t const start = ((((*this).index)++));
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<lexer::Token,lexer::Token>{
-auto __jakt_enum_value = (((*this).peek()));
-if (__jakt_enum_value == '=') {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::DoubleEqual(((*this).span(start,(++(((*this).index)))))) } );
-}
-else if (__jakt_enum_value == '>') {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::FatArrow(((*this).span(start,(++(((*this).index)))))) } );
-}
-else {
-return JaktInternal::ExplicitValue( lexer::Token { typename lexer::Token::Equal(((*this).span((JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL))),((*this).index)))) } );
-}
-}()))
-);
-}
-}
-
 ErrorOr<JaktInternal::DynamicArray<lexer::Token>> lexer::Lexer::lex(NonnullRefPtr<compiler::Compiler> const compiler) {
 {
 lexer::Lexer lexer = lexer::Lexer(static_cast<size_t>(0ULL),((compiler)->current_file_contents),compiler,JaktInternal::OptionalNone());
diff --git a/bootstrap/stage0/lexer.h b/bootstrap/stage0/lexer.h
index a30667264..879d1996f 100644
--- a/bootstrap/stage0/lexer.h
+++ b/bootstrap/stage0/lexer.h
@@ -7,41 +7,60 @@ namespace Jakt {
 namespace lexer {
 struct Lexer {
   public:
-size_t index;JaktInternal::DynamicArray<u8> input;NonnullRefPtr<compiler::Compiler> compiler;JaktInternal::Optional<JaktInternal::DynamicArray<u8>> comment_contents;ErrorOr<lexer::Token> lex_quoted_string(u8 const delimiter);
+size_t index;JaktInternal::DynamicArray<u8> input;NonnullRefPtr<compiler::Compiler> compiler;JaktInternal::Optional<JaktInternal::DynamicArray<u8>> comment_contents;ErrorOr<JaktInternal::Optional<DeprecatedString>> consume_comment_contents();
+ErrorOr<lexer::Token> lex_quoted_string(u8 const delimiter);
 ErrorOr<JaktInternal::Optional<lexer::Token>> next();
-ErrorOr<JaktInternal::Optional<DeprecatedString>> consume_comment_contents();
 ErrorOr<lexer::Token> lex_character_constant_or_name();
 lexer::Token lex_dot();
-ErrorOr<lexer::Token> lex_forward_slash();
 lexer::Token lex_question_mark();
+ErrorOr<lexer::Token> lex_forward_slash();
 u8 peek_behind(size_t const steps) const;
 u8 peek_ahead(size_t const steps) const;
 lexer::Token lex_asterisk();
+lexer::Token lex_minus();
 u8 peek() const;
 lexer::Token lex_percent_sign();
 ErrorOr<lexer::Token> lex_number_or_name();
-lexer::Token lex_minus();
+lexer::Token lex_less_than();
 bool eof() const;
+Lexer(size_t a_index, JaktInternal::DynamicArray<u8> a_input, NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::Optional<JaktInternal::DynamicArray<u8>> a_comment_contents);
+
 lexer::Token lex_ampersand();
 utility::Span span(size_t const start, size_t const end) const;
 lexer::Token lex_plus();
 lexer::Token lex_exclamation_point();
 ErrorOr<lexer::LiteralSuffix> consume_numeric_literal_suffix();
 lexer::Token lex_colon();
-Lexer(size_t a_index, JaktInternal::DynamicArray<u8> a_input, NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::Optional<JaktInternal::DynamicArray<u8>> a_comment_contents);
-
 bool valid_digit(lexer::LiteralPrefix const prefix, u8 const digit, bool const decimal_allowed);
 ErrorOr<void> error(DeprecatedString const message, utility::Span const span);
+lexer::Token lex_equals();
 ErrorOr<DeprecatedString> substring(size_t const start, size_t const length) const;
 lexer::Token lex_greater_than();
 lexer::Token lex_pipe();
 lexer::Token lex_caret();
 ErrorOr<lexer::Token> lex_number();
-lexer::Token lex_less_than();
-lexer::Token lex_equals();
 static ErrorOr<JaktInternal::DynamicArray<lexer::Token>> lex(NonnullRefPtr<compiler::Compiler> const compiler);
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace LiteralSuffix_Details {
+};namespace LiteralPrefix_Details {
+struct None {
+};
+struct Hexadecimal {
+};
+struct Octal {
+};
+struct Binary {
+};
+}
+struct LiteralPrefix : public Variant<LiteralPrefix_Details::None, LiteralPrefix_Details::Hexadecimal, LiteralPrefix_Details::Octal, LiteralPrefix_Details::Binary> {
+using Variant<LiteralPrefix_Details::None, LiteralPrefix_Details::Hexadecimal, LiteralPrefix_Details::Octal, LiteralPrefix_Details::Binary>::Variant;
+    using None = LiteralPrefix_Details::None;
+    using Hexadecimal = LiteralPrefix_Details::Hexadecimal;
+    using Octal = LiteralPrefix_Details::Octal;
+    using Binary = LiteralPrefix_Details::Binary;
+ErrorOr<DeprecatedString> debug_description() const;
+DeprecatedString to_string() const;
+};
+namespace LiteralSuffix_Details {
 struct None {
 };
 struct UZ {
@@ -84,25 +103,6 @@ using Variant<LiteralSuffix_Details::None, LiteralSuffix_Details::UZ, LiteralSuf
 ErrorOr<DeprecatedString> debug_description() const;
 DeprecatedString to_string() const;
 };
-namespace LiteralPrefix_Details {
-struct None {
-};
-struct Hexadecimal {
-};
-struct Octal {
-};
-struct Binary {
-};
-}
-struct LiteralPrefix : public Variant<LiteralPrefix_Details::None, LiteralPrefix_Details::Hexadecimal, LiteralPrefix_Details::Octal, LiteralPrefix_Details::Binary> {
-using Variant<LiteralPrefix_Details::None, LiteralPrefix_Details::Hexadecimal, LiteralPrefix_Details::Octal, LiteralPrefix_Details::Binary>::Variant;
-    using None = LiteralPrefix_Details::None;
-    using Hexadecimal = LiteralPrefix_Details::Hexadecimal;
-    using Octal = LiteralPrefix_Details::Octal;
-    using Binary = LiteralPrefix_Details::Binary;
-ErrorOr<DeprecatedString> debug_description() const;
-DeprecatedString to_string() const;
-};
 namespace Token_Details {
 struct SingleQuotedString {
 DeprecatedString quote;
@@ -1033,14 +1033,14 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::lexer::LiteralSuffix> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::lexer::LiteralSuffix const& value) {
+template<>struct Jakt::Formatter<Jakt::lexer::LiteralPrefix> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::lexer::LiteralPrefix const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::lexer::LiteralPrefix> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::lexer::LiteralPrefix const& value) {
+template<>struct Jakt::Formatter<Jakt::lexer::LiteralSuffix> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::lexer::LiteralSuffix const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
diff --git a/bootstrap/stage0/main.cpp b/bootstrap/stage0/main.cpp
index d149dcf6f..7b3e3227a 100644
--- a/bootstrap/stage0/main.cpp
+++ b/bootstrap/stage0/main.cpp
@@ -144,119 +144,6 @@ out(Jakt::DeprecatedString("{}"sv),TRY((((formatted_file).to_string()))));
 return {};
 }
 
-ErrorOr<DeprecatedString> indent(size_t const level) {
-{
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(level)});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-(output += Jakt::DeprecatedString("    "sv));
-}
-
-}
-}
-
-return (output);
-}
-}
-
-DeprecatedString help() {
-{
-DeprecatedString output = Jakt::DeprecatedString("Flags:\n"sv);
-(output += Jakt::DeprecatedString("  -h,--help\t\t\t\tPrint this help and exit.\n"sv));
-(output += Jakt::DeprecatedString("  -O\t\t\t\t\tBuild an optimized executable.\n"sv));
-(output += Jakt::DeprecatedString("  -dl\t\t\t\t\tPrint debug info for the lexer.\n"sv));
-(output += Jakt::DeprecatedString("  -dp\t\t\t\t\tPrint debug info for the parser.\n"sv));
-(output += Jakt::DeprecatedString("  -dt\t\t\t\t\tPrint debug info for the typechecker.\n"sv));
-(output += Jakt::DeprecatedString("  -S,--emit-cpp-source-only\t\tOnly output source (do not build).\n"sv));
-(output += Jakt::DeprecatedString("  -T,--target-triple TARGET\t\tSpecify the target triple used for the build, defaults to native.\n"sv));
-(output += Jakt::DeprecatedString("  --runtime-library-path PATH\t\tSpecify the path to the runtime library.\n"sv));
-(output += Jakt::DeprecatedString("  -J,--jobs NUMBER\t\t\tSpecify the number of jobs to run in parallel, defaults to 2 (1 on windows).\n"sv));
-(output += Jakt::DeprecatedString("  -cr,--compile-run\t\t\tBuild and run an executable file.\n"sv));
-(output += Jakt::DeprecatedString("  -r,--run\t\t\t\tRun the given file without compiling it (all positional arguments after the file name will be passed to main).\n"sv));
-(output += Jakt::DeprecatedString("  -d\t\t\t\t\tInsert debug statement spans in generated C++ code.\n"sv));
-(output += Jakt::DeprecatedString("  --debug-print\t\t\t\tOutput debug print.\n"sv));
-(output += Jakt::DeprecatedString("  -p,--prettify-cpp-source\t\tRun emitted C++ source through clang-format.\n"sv));
-(output += Jakt::DeprecatedString("  -c,--check-only\t\t\tOnly check the code for errors.\n"sv));
-(output += Jakt::DeprecatedString("  -j,--json-errors\t\t\tEmit machine-readable (JSON) errors.\n"sv));
-(output += Jakt::DeprecatedString("  -H,--type-hints\t\t\tEmit machine-readable type hints (for IDE integration).\n"sv));
-(output += Jakt::DeprecatedString("  -f,--format\t\t\t\tFormat a file or directory and output the result.\n"sv));
-(output += Jakt::DeprecatedString("  -fi,--format-inplace\t\t\tFormat a file or directory and save the result inplace.\n"sv));
-(output += Jakt::DeprecatedString("  -fd,--format-debug\t\t\tOutput debug info for the formatter.\n"sv));
-(output += Jakt::DeprecatedString("  -fr,--format-range\t\t\tEmit part of the document with formatting applied.\n"sv));
-(output += Jakt::DeprecatedString("  --try-hints\t\t\t\tEmit machine-readable try hints (for IDE integration).\n"sv));
-(output += Jakt::DeprecatedString("  --repl\t\t\t\tStart a Read-Eval-Print loop session.\n"sv));
-(output += Jakt::DeprecatedString("  --print-symbols\t\t\tEmit a machine-readable (JSON) symbol tree.\n"sv));
-(output += Jakt::DeprecatedString("\nOptions:\n"sv));
-(output += Jakt::DeprecatedString("  -F,--clang-format-path PATH\t\tPath to clang-format executable.\n\t\t\t\t\tDefaults to clang-format\n"sv));
-(output += Jakt::DeprecatedString("  -D,--dot-clang-format-path PATH\tPath to the .clang-format file to use.\n\t\t\t\t\tDefaults to none, invoking clangs default .clang-format file handling.\n"sv));
-(output += Jakt::DeprecatedString("  -R,--runtime-path PATH\t\tPath of the Jakt runtime headers.\n\t\t\t\t\tDefaults to $PWD/runtime.\n"sv));
-(output += Jakt::DeprecatedString("  -B,--binary-dir PATH\t\t\tOutput directory for compiled files.\n\t\t\t\t\tDefaults to $PWD/build.\n"sv));
-(output += Jakt::DeprecatedString("  -C,--cxx-compiler-path PATH\t\tPath of the C++ compiler to use when compiling the generated sources.\n\t\t\t\t\tDefaults to clang++.\n"sv));
-(output += Jakt::DeprecatedString("  -I PATH\t\t\t\tAdd PATH to compiler's include list. Can be specified multiple times.\n"sv));
-(output += Jakt::DeprecatedString("  -L PATH\t\t\t\tAdd PATH to linker's search list. Can be specified multiple times.\n"sv));
-(output += Jakt::DeprecatedString("  -l,--link-with LIB\t\t\tLink executable with LIB. Can be specified multiple times.\n"sv));
-(output += Jakt::DeprecatedString("  -o,--output-filename FILE\t\tName of the output binary.\n\t\t\t\t\tDefaults to the input-filename without the extension.\n"sv));
-(output += Jakt::DeprecatedString("  -g,--goto-def INDEX\t\t\tReturn the span for the definition at index.\n"sv));
-(output += Jakt::DeprecatedString("  -t,--goto-type-def INDEX\t\tReturn the span for the type definition at index.\n"sv));
-(output += Jakt::DeprecatedString("  -e,--hover INDEX\t\t\tReturn the type of element at index.\n"sv));
-(output += Jakt::DeprecatedString("  -m,--completions INDEX\t\tReturn dot completions at index.\n"sv));
-(output += Jakt::DeprecatedString("  --create NAME\t\t\t\tCreate sample project in $PWD/NAME\n"sv));
-(output += Jakt::DeprecatedString("  --ak-is-my-only-stdlib\t\tForget about interop, AK is the one and only STL.\n"sv));
-return (output);
-}
-}
-
-DeprecatedString usage() {
-{
-return (Jakt::DeprecatedString("usage: jakt [-h] [OPTIONS] <filename>"sv));
-}
-}
-
-ErrorOr<JaktInternal::Optional<FormatRange>> parse_format_range(DeprecatedString const range,size_t const input_file_length) {
-{
-JaktInternal::DynamicArray<DeprecatedString> const parts = ((range).split(':'));
-if (((parts).is_empty())){
-return (FormatRange(static_cast<size_t>(0ULL),input_file_length));
-}
-JaktInternal::Optional<u32> const start_input = ((((parts)[static_cast<i64>(0LL)])).to_uint());
-if ((!(((start_input).has_value())))){
-return (JaktInternal::OptionalNone());
-}
-size_t const start = (infallible_integer_cast<size_t>(((start_input.value()))));
-size_t const end = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,ErrorOr<JaktInternal::Optional<FormatRange>>>{
-auto __jakt_enum_value = (((parts).size()));
-if (__jakt_enum_value == static_cast<size_t>(1ULL)) {
-return JaktInternal::ExplicitValue(input_file_length);
-}
-else if (__jakt_enum_value == static_cast<size_t>(2ULL)) {
-return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_864; {
-JaktInternal::Optional<u32> const end_input = ((((parts)[static_cast<i64>(1LL)])).to_uint());
-if ((!(((end_input).has_value())))){
-return (JaktInternal::OptionalNone());
-}
-__jakt_var_864 = (infallible_integer_cast<size_t>(((end_input.value())))); goto __jakt_label_770;
-
-}
-__jakt_label_770:; __jakt_var_864.release_value(); }));
-}
-else {
-{
-return (JaktInternal::OptionalNone());
-}
-}
-}()))
-;
-return (FormatRange(start,end));
-}
-}
-
 ErrorOr<int> main(JaktInternal::DynamicArray<DeprecatedString> const args) {
 
 
@@ -268,17 +155,17 @@ ErrorOr<int> main(JaktInternal::DynamicArray<DeprecatedString> const args) {
 {
 if ((((args).size()) <= static_cast<size_t>(1ULL))){
 warnln(Jakt::DeprecatedString("{}"sv),usage());
-return (static_cast<i64>(1LL));
+return (static_cast<size_t>(1ULL));
 }
 jakt__arguments::ArgsParser args_parser = TRY((jakt__arguments::ArgsParser::from_args(args)));
 if (TRY((((args_parser).flag((TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("-h"sv), Jakt::DeprecatedString("--help"sv)}))))))))){
 outln(Jakt::DeprecatedString("{}\n"sv),usage());
 outln(Jakt::DeprecatedString("{}"sv),help());
-return (static_cast<i64>(0LL));
+return (static_cast<size_t>(0ULL));
 }
 if (TRY((((args_parser).flag((TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("-v"sv), Jakt::DeprecatedString("--version"sv)}))))))))){
 outln(Jakt::DeprecatedString("unreleased"sv));
-return (static_cast<i64>(0LL));
+return (static_cast<size_t>(0ULL));
 }
 jakt__path::Path const current_executable_path = TRY((jakt__path::Path::from_string(TRY((File::current_executable_path())))));
 jakt__path::Path const install_base_path = TRY((((TRY((((current_executable_path).parent())))).parent())));
@@ -337,15 +224,15 @@ bool const format_inplace = TRY((((args_parser).flag((TRY((DynamicArray<Deprecat
 bool const format_debug = TRY((((args_parser).flag((TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("-fd"sv), Jakt::DeprecatedString("--format-debug"sv)}))))))));
 DeprecatedString const input_format_range = TRY((((args_parser).option((TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("-fr"sv), Jakt::DeprecatedString("--format-range"sv)})))))))).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); });
 bool const ak_stdlib = TRY((((args_parser).flag((TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("--ak-is-my-only-stdlib"sv)}))))))));
-size_t const max_concurrent = (infallible_integer_cast<size_t>((({ Optional<u32> __jakt_var_865;
-auto __jakt_var_866 = [&]() -> ErrorOr<u32> { return TRY((value_or_throw<u32>(((compiler_job_count).to_uint())))); }();
-if (__jakt_var_866.is_error()) {{
+size_t const max_concurrent = (infallible_integer_cast<size_t>((({ Optional<u32> __jakt_var_864;
+auto __jakt_var_865 = [&]() -> ErrorOr<u32> { return TRY((value_or_throw<u32>(((compiler_job_count).to_uint())))); }();
+if (__jakt_var_865.is_error()) {{
 warnln(Jakt::DeprecatedString("error: invalid value for --jobs: {}"sv),compiler_job_count);
 return (static_cast<i64>(1LL));
 }
-} else {__jakt_var_865 = __jakt_var_866.release_value();
+} else {__jakt_var_864 = __jakt_var_865.release_value();
 }
-__jakt_var_865.release_value(); }))));
+__jakt_var_864.release_value(); }))));
 if (TRY((((args_parser).flag((TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("--repl"sv)}))))))))){
 repl::REPL repl = TRY((repl::REPL::create(TRY((jakt__path::Path::from_parts((TRY((DynamicArray<DeprecatedString>::create_with({runtime_path, Jakt::DeprecatedString("jaktlib"sv)}))))))),target_triple)));
 TRY((((repl).run())));
@@ -552,7 +439,7 @@ JaktInternal::Optional<types::CheckedParameter> const first_main_param = ((((((c
 JaktInternal::DynamicArray<types::Value> const arguments = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::Value>,ErrorOr<int>>{
 auto __jakt_enum_value = (((first_main_param).has_value()));
 if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<types::Value>> __jakt_var_867; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<types::Value>> __jakt_var_866; {
 JaktInternal::DynamicArray<types::Value> passed_arguments = (TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktString>((file_name.value())))),call_span)}))));
 {
 JaktInternal::ArrayIterator<DeprecatedString> _magic = ((interpreted_main_arguments).iterator());
@@ -569,10 +456,10 @@ TRY((((passed_arguments).push(types::Value(TRY((types::ValueImpl::template __jak
 }
 }
 
-__jakt_var_867 = (TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(passed_arguments,(((((first_main_param.value())).variable))->type_id)))),call_span)})))); goto __jakt_label_771;
+__jakt_var_866 = (TRY((DynamicArray<types::Value>::create_with({types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::JaktArray>(passed_arguments,(((((first_main_param.value())).variable))->type_id)))),call_span)})))); goto __jakt_label_770;
 
 }
-__jakt_label_771:; __jakt_var_867.release_value(); }));
+__jakt_label_770:; __jakt_var_866.release_value(); }));
 }
 else {
 return JaktInternal::ExplicitValue((TRY((DynamicArray<types::Value>::create_with({})))));
@@ -732,8 +619,8 @@ DeprecatedString const contents = ((contents_module_file_path_).template get<0>(
 DeprecatedString const module_file_path = ((contents_module_file_path_).template get<1>());
 
 jakt__path::Path const path = TRY((((binary_dir).join(file))));
-auto __jakt_var_869 = [&]() -> ErrorOr<void> { return TRY((utility::write_to_file(contents,((path).to_string())))), ErrorOr<void>{}; }();
-if (__jakt_var_869.is_error()) {auto error = __jakt_var_869.release_error();
+auto __jakt_var_868 = [&]() -> ErrorOr<void> { return TRY((utility::write_to_file(contents,((path).to_string())))), ErrorOr<void>{}; }();
+if (__jakt_var_868.is_error()) {auto error = __jakt_var_868.release_error();
 {
 warnln(Jakt::DeprecatedString("Error: Could not write to file: {} ({})"sv),file,error);
 return (static_cast<i64>(1LL));
@@ -752,12 +639,12 @@ TRY((((depfile_builder).append('\n'))));
 }
 
 if (((generate_depfile).has_value())){
-auto __jakt_var_870 = [&]() -> ErrorOr<void> {{
+auto __jakt_var_869 = [&]() -> ErrorOr<void> {{
 TRY((utility::write_to_file(TRY((((depfile_builder).to_string()))),(generate_depfile.value()))));
 }
 
 ;return {};}();
-if (__jakt_var_870.is_error()) {auto error = __jakt_var_870.release_error();{
+if (__jakt_var_869.is_error()) {auto error = __jakt_var_869.release_error();{
 warnln(Jakt::DeprecatedString("Error: Could not write to file list ({})"sv),error);
 return (static_cast<i64>(1LL));
 }
@@ -820,20 +707,20 @@ JaktInternal::DynamicArray<DeprecatedString> extra_compiler_flags = (TRY((Dynami
 if (ak_stdlib){
 TRY((((extra_compiler_flags).push(Jakt::DeprecatedString("-DJAKT_USING_AK_AS_STANDARD_LIBRARY=1"sv)))));
 }
-auto __jakt_var_872 = [&]() -> ErrorOr<void> { return TRY((((builder).build_all(binary_dir,(([cxx_compiler_path, runtime_path, extra_include_paths, optimize, extra_compiler_flags](DeprecatedString input_filename, DeprecatedString output_filename) -> ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> {
+auto __jakt_var_871 = [&]() -> ErrorOr<void> { return TRY((((builder).build_all(binary_dir,(([cxx_compiler_path, runtime_path, extra_include_paths, optimize, extra_compiler_flags](DeprecatedString input_filename, DeprecatedString output_filename) -> ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> {
 {
 return (TRY((jakt__platform__unknown_compiler::run_compiler(cxx_compiler_path,input_filename,output_filename,runtime_path,extra_include_paths,(TRY((DynamicArray<DeprecatedString>::create_with({})))),(TRY((DynamicArray<DeprecatedString>::create_with({})))),optimize,extra_compiler_flags))));
 }
 }
 )))))), ErrorOr<void>{}; }();
-if (__jakt_var_872.is_error()) {{
+if (__jakt_var_871.is_error()) {{
 return (static_cast<i64>(1LL));
 }
 }
 ;
 if (((link_archive).has_value())){
-auto __jakt_var_874 = [&]() -> ErrorOr<void> { return TRY((((builder).link_into_archive(archiver_path.value_or_lazy_evaluated([&] { return Jakt::DeprecatedString("ar"sv); }),(link_archive.value()))))), ErrorOr<void>{}; }();
-if (__jakt_var_874.is_error()) {{
+auto __jakt_var_873 = [&]() -> ErrorOr<void> { return TRY((((builder).link_into_archive(archiver_path.value_or_lazy_evaluated([&] { return Jakt::DeprecatedString("ar"sv); }),(link_archive.value()))))), ErrorOr<void>{}; }();
+if (__jakt_var_873.is_error()) {{
 return (static_cast<i64>(1LL));
 }
 }
@@ -880,8 +767,8 @@ if ((false && (TRY((((TRY((jakt__path::Path::from_string(cxx_compiler_path)))).b
 TRY((((extra_arguments).push(Jakt::DeprecatedString("/link"sv)))));
 TRY((((extra_arguments).push(Jakt::DeprecatedString("/subsystem:console"sv)))));
 }
-auto __jakt_var_876 = [&]() -> ErrorOr<void> { return TRY((((builder).link_into_executable(cxx_compiler_path,output_filename,extra_arguments)))), ErrorOr<void>{}; }();
-if (__jakt_var_876.is_error()) {{
+auto __jakt_var_875 = [&]() -> ErrorOr<void> { return TRY((((builder).link_into_executable(cxx_compiler_path,output_filename,extra_arguments)))), ErrorOr<void>{}; }();
+if (__jakt_var_875.is_error()) {{
 return (static_cast<i64>(1LL));
 }
 }
@@ -892,10 +779,124 @@ return (static_cast<i64>(1LL));
 if (run_executable){
 return (system(((output_filename).characters())));
 }
+return (static_cast<i64>(0LL));
 }
 return 0;
 }
 
+DeprecatedString usage() {
+{
+return (Jakt::DeprecatedString("usage: jakt [-h] [OPTIONS] <filename>"sv));
+}
+}
+
+DeprecatedString help() {
+{
+DeprecatedString output = Jakt::DeprecatedString("Flags:\n"sv);
+(output += Jakt::DeprecatedString("  -h,--help\t\t\t\tPrint this help and exit.\n"sv));
+(output += Jakt::DeprecatedString("  -O\t\t\t\t\tBuild an optimized executable.\n"sv));
+(output += Jakt::DeprecatedString("  -dl\t\t\t\t\tPrint debug info for the lexer.\n"sv));
+(output += Jakt::DeprecatedString("  -dp\t\t\t\t\tPrint debug info for the parser.\n"sv));
+(output += Jakt::DeprecatedString("  -dt\t\t\t\t\tPrint debug info for the typechecker.\n"sv));
+(output += Jakt::DeprecatedString("  -S,--emit-cpp-source-only\t\tOnly output source (do not build).\n"sv));
+(output += Jakt::DeprecatedString("  -T,--target-triple TARGET\t\tSpecify the target triple used for the build, defaults to native.\n"sv));
+(output += Jakt::DeprecatedString("  --runtime-library-path PATH\t\tSpecify the path to the runtime library.\n"sv));
+(output += Jakt::DeprecatedString("  -J,--jobs NUMBER\t\t\tSpecify the number of jobs to run in parallel, defaults to 2 (1 on windows).\n"sv));
+(output += Jakt::DeprecatedString("  -cr,--compile-run\t\t\tBuild and run an executable file.\n"sv));
+(output += Jakt::DeprecatedString("  -r,--run\t\t\t\tRun the given file without compiling it (all positional arguments after the file name will be passed to main).\n"sv));
+(output += Jakt::DeprecatedString("  -d\t\t\t\t\tInsert debug statement spans in generated C++ code.\n"sv));
+(output += Jakt::DeprecatedString("  --debug-print\t\t\t\tOutput debug print.\n"sv));
+(output += Jakt::DeprecatedString("  -p,--prettify-cpp-source\t\tRun emitted C++ source through clang-format.\n"sv));
+(output += Jakt::DeprecatedString("  -c,--check-only\t\t\tOnly check the code for errors.\n"sv));
+(output += Jakt::DeprecatedString("  -j,--json-errors\t\t\tEmit machine-readable (JSON) errors.\n"sv));
+(output += Jakt::DeprecatedString("  -H,--type-hints\t\t\tEmit machine-readable type hints (for IDE integration).\n"sv));
+(output += Jakt::DeprecatedString("  -f,--format\t\t\t\tFormat a file or directory and output the result.\n"sv));
+(output += Jakt::DeprecatedString("  -fi,--format-inplace\t\t\tFormat a file or directory and save the result inplace.\n"sv));
+(output += Jakt::DeprecatedString("  -fd,--format-debug\t\t\tOutput debug info for the formatter.\n"sv));
+(output += Jakt::DeprecatedString("  -fr,--format-range\t\t\tEmit part of the document with formatting applied.\n"sv));
+(output += Jakt::DeprecatedString("  --try-hints\t\t\t\tEmit machine-readable try hints (for IDE integration).\n"sv));
+(output += Jakt::DeprecatedString("  --repl\t\t\t\tStart a Read-Eval-Print loop session.\n"sv));
+(output += Jakt::DeprecatedString("  --print-symbols\t\t\tEmit a machine-readable (JSON) symbol tree.\n"sv));
+(output += Jakt::DeprecatedString("\nOptions:\n"sv));
+(output += Jakt::DeprecatedString("  -F,--clang-format-path PATH\t\tPath to clang-format executable.\n\t\t\t\t\tDefaults to clang-format\n"sv));
+(output += Jakt::DeprecatedString("  -D,--dot-clang-format-path PATH\tPath to the .clang-format file to use.\n\t\t\t\t\tDefaults to none, invoking clangs default .clang-format file handling.\n"sv));
+(output += Jakt::DeprecatedString("  -R,--runtime-path PATH\t\tPath of the Jakt runtime headers.\n\t\t\t\t\tDefaults to $PWD/runtime.\n"sv));
+(output += Jakt::DeprecatedString("  -B,--binary-dir PATH\t\t\tOutput directory for compiled files.\n\t\t\t\t\tDefaults to $PWD/build.\n"sv));
+(output += Jakt::DeprecatedString("  -C,--cxx-compiler-path PATH\t\tPath of the C++ compiler to use when compiling the generated sources.\n\t\t\t\t\tDefaults to clang++.\n"sv));
+(output += Jakt::DeprecatedString("  -I PATH\t\t\t\tAdd PATH to compiler's include list. Can be specified multiple times.\n"sv));
+(output += Jakt::DeprecatedString("  -L PATH\t\t\t\tAdd PATH to linker's search list. Can be specified multiple times.\n"sv));
+(output += Jakt::DeprecatedString("  -l,--link-with LIB\t\t\tLink executable with LIB. Can be specified multiple times.\n"sv));
+(output += Jakt::DeprecatedString("  -o,--output-filename FILE\t\tName of the output binary.\n\t\t\t\t\tDefaults to the input-filename without the extension.\n"sv));
+(output += Jakt::DeprecatedString("  -g,--goto-def INDEX\t\t\tReturn the span for the definition at index.\n"sv));
+(output += Jakt::DeprecatedString("  -t,--goto-type-def INDEX\t\tReturn the span for the type definition at index.\n"sv));
+(output += Jakt::DeprecatedString("  -e,--hover INDEX\t\t\tReturn the type of element at index.\n"sv));
+(output += Jakt::DeprecatedString("  -m,--completions INDEX\t\tReturn dot completions at index.\n"sv));
+(output += Jakt::DeprecatedString("  --create NAME\t\t\t\tCreate sample project in $PWD/NAME\n"sv));
+(output += Jakt::DeprecatedString("  --ak-is-my-only-stdlib\t\tForget about interop, AK is the one and only STL.\n"sv));
+return (output);
+}
+}
+
+ErrorOr<JaktInternal::Optional<FormatRange>> parse_format_range(DeprecatedString const range,size_t const input_file_length) {
+{
+JaktInternal::DynamicArray<DeprecatedString> const parts = ((range).split(':'));
+if (((parts).is_empty())){
+return (FormatRange(static_cast<size_t>(0ULL),input_file_length));
+}
+JaktInternal::Optional<u32> const start_input = ((((parts)[static_cast<i64>(0LL)])).to_uint());
+if ((!(((start_input).has_value())))){
+return (JaktInternal::OptionalNone());
+}
+size_t const start = (infallible_integer_cast<size_t>(((start_input.value()))));
+size_t const end = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,ErrorOr<JaktInternal::Optional<FormatRange>>>{
+auto __jakt_enum_value = (((parts).size()));
+if (__jakt_enum_value == static_cast<size_t>(1ULL)) {
+return JaktInternal::ExplicitValue(input_file_length);
+}
+else if (__jakt_enum_value == static_cast<size_t>(2ULL)) {
+return JaktInternal::ExplicitValue(({ Optional<size_t> __jakt_var_876; {
+JaktInternal::Optional<u32> const end_input = ((((parts)[static_cast<i64>(1LL)])).to_uint());
+if ((!(((end_input).has_value())))){
+return (JaktInternal::OptionalNone());
+}
+__jakt_var_876 = (infallible_integer_cast<size_t>(((end_input.value())))); goto __jakt_label_771;
+
+}
+__jakt_label_771:; __jakt_var_876.release_value(); }));
+}
+else {
+{
+return (JaktInternal::OptionalNone());
+}
+}
+}()))
+;
+return (FormatRange(start,end));
+}
+}
+
+ErrorOr<DeprecatedString> indent(size_t const level) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(level)});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+(output += Jakt::DeprecatedString("    "sv));
+}
+
+}
+}
+
+return (output);
+}
+}
+
 ErrorOr<DeprecatedString> FormatRange::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("FormatRange("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("start: {}, ", start));
diff --git a/bootstrap/stage0/parser.cpp b/bootstrap/stage0/parser.cpp
index 017579fa6..681efad0e 100644
--- a/bootstrap/stage0/parser.cpp
+++ b/bootstrap/stage0/parser.cpp
@@ -24,83 +24,72 @@ return (f32_value);
 }
 }
 
-ErrorOr<DeprecatedString> parser::ParsedGenericParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedGenericParameter("sv));{
+ErrorOr<DeprecatedString> parser::ParsedMatchCase::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedMatchCase("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("requires_list: {}", requires_list));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("patterns: {}, ", patterns));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("marker_span: {}, ", marker_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("body: {}", body));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedGenericParameter::ParsedGenericParameter(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> a_requires_list) :name(move(a_name)), span(move(a_span)), requires_list(move(a_requires_list)){}
-
-ErrorOr<DeprecatedString> parser::ParsedField::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedField("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("var_decl: {}, ", var_decl));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("visibility: {}, ", visibility));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("default_value: {}", default_value));
+bool parser::ParsedMatchCase::has_equal_pattern(parser::ParsedMatchCase const rhs_match_case) const {
+{
+if ((((((*this).patterns)).size()) == ((((rhs_match_case).patterns)).size()))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((((*this).patterns)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if ((!(((((((*this).patterns))[i])).is_equal_pattern(((((rhs_match_case).patterns))[i])))))){
+return (false);
+}
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedField::ParsedField(parser::ParsedVarDecl a_var_decl, parser::Visibility a_visibility, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_value) :var_decl(move(a_var_decl)), visibility(move(a_visibility)), default_value(move(a_default_value)){}
 
-ErrorOr<DeprecatedString> parser::EnumVariantPatternArgument::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("EnumVariantPatternArgument("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: {}, ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("binding: \"{}\", ", binding));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_reference: {}, ", is_reference));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_mutable: {}", is_mutable));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::EnumVariantPatternArgument::EnumVariantPatternArgument(JaktInternal::Optional<DeprecatedString> a_name, DeprecatedString a_binding, utility::Span a_span, bool a_is_reference, bool a_is_mutable) :name(move(a_name)), binding(move(a_binding)), span(move(a_span)), is_reference(move(a_is_reference)), is_mutable(move(a_is_mutable)){}
+}
 
-bool parser::EnumVariantPatternArgument::equals(parser::EnumVariantPatternArgument const rhs_variant_pattern_argument) const {
-{
-if ((((*this).binding) != ((rhs_variant_pattern_argument).binding))){
+return (true);
+}
+else {
 return (false);
 }
-if ((((((*this).name)).has_value()) && ((((rhs_variant_pattern_argument).name)).has_value()))){
-return (((((*this).name).value()) == (((rhs_variant_pattern_argument).name).value())));
+
 }
-if ((((*this).is_reference) != ((rhs_variant_pattern_argument).is_reference))){
-return (false);
 }
-if ((((*this).is_mutable) != ((rhs_variant_pattern_argument).is_mutable))){
-return (false);
+
+bool parser::ParsedMatchCase::equals(parser::ParsedMatchCase const rhs_match_case) const {
+{
+if ((((((*this).patterns)).size()) == ((((rhs_match_case).patterns)).size()))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((((*this).patterns)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return (((!(((((*this).name)).has_value()))) && (!(((((rhs_variant_pattern_argument).name)).has_value())))));
+size_t i = (_magic_value.value());
+{
+if ((!(((((((*this).patterns))[i])).equals(((((rhs_match_case).patterns))[i])))))){
+return (false);
 }
 }
 
-ErrorOr<DeprecatedString> parser::ParsedPatternDefault::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedPatternDefault("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("variable: {}, ", variable));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("value: {}", value));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedPatternDefault::ParsedPatternDefault(parser::ParsedVarDecl a_variable, NonnullRefPtr<typename parser::ParsedExpression> a_value) :variable(move(a_variable)), value(move(a_value)){}
+}
 
-ErrorOr<DeprecatedString> parser::ParsedRecord::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedRecord("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_parameters: {}, ", generic_parameters));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("definition_linkage: {}, ", definition_linkage));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("implements_list: {}, ", implements_list));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("methods: {}, ", methods));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("record_type: {}, ", record_type));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}", external_name));
+return (((((*this).body)).equals(((rhs_match_case).body))));
+}
+else {
+return (false);
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedRecord::ParsedRecord(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<parser::ParsedGenericParameter> a_generic_parameters, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> a_implements_list, JaktInternal::DynamicArray<parser::ParsedMethod> a_methods, parser::RecordType a_record_type, JaktInternal::Optional<DeprecatedString> a_external_name) :name(move(a_name)), name_span(move(a_name_span)), generic_parameters(move(a_generic_parameters)), definition_linkage(move(a_definition_linkage)), implements_list(move(a_implements_list)), methods(move(a_methods)), record_type(move(a_record_type)), external_name(move(a_external_name)){}
 
-ErrorOr<DeprecatedString> parser::ParsedExternalTraitImplementation::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedExternalTraitImplementation("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("for_type: {}, ", for_type));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("methods: {}", methods));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedExternalTraitImplementation::ParsedExternalTraitImplementation(NonnullRefPtr<typename parser::ParsedType> a_for_type, JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> a_traits, JaktInternal::DynamicArray<parser::ParsedMethod> a_methods) :for_type(move(a_for_type)), traits(move(a_traits)), methods(move(a_methods)){}
+}
+
+parser::ParsedMatchCase::ParsedMatchCase(JaktInternal::DynamicArray<parser::ParsedMatchPattern> a_patterns, utility::Span a_marker_span, parser::ParsedMatchBody a_body) :patterns(move(a_patterns)), marker_span(move(a_marker_span)), body(move(a_body)){}
 
 ErrorOr<DeprecatedString> parser::ParsedFunction::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedFunction("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
@@ -160,34 +149,6 @@ return (true);
 }
 }
 
-ErrorOr<DeprecatedString> parser::ParsedExternImport::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedExternImport("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_c: {}, ", is_c));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("assigned_namespace: {}, ", assigned_namespace));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("before_include: {}, ", before_include));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("after_include: {}", after_include));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<bool> parser::ParsedExternImport::is_equivalent_to(parser::ParsedExternImport const other) const {
-{
-return ((((*this).is_c) && (((other).is_c) && ((((*this).get_path()) == ((other).get_path())) && (((*this).get_name()) == ((other).get_name()))))));
-}
-}
-
-parser::ParsedExternImport::ParsedExternImport(bool a_is_c, parser::ParsedNamespace a_assigned_namespace, JaktInternal::DynamicArray<parser::IncludeAction> a_before_include, JaktInternal::DynamicArray<parser::IncludeAction> a_after_include) :is_c(move(a_is_c)), assigned_namespace(move(a_assigned_namespace)), before_include(move(a_before_include)), after_include(move(a_after_include)){}
-
-DeprecatedString parser::ParsedExternImport::get_name() const {
-{
-return ((((((*this).assigned_namespace)).name).value()));
-}
-}
-
-DeprecatedString parser::ParsedExternImport::get_path() const {
-{
-return ((((((*this).assigned_namespace)).import_path_if_extern).value()));
-}
-}
-
 ErrorOr<DeprecatedString> parser::ParsedModuleImport::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedModuleImport("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module_name: {}, ", module_name));
@@ -195,14 +156,6 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("import_list: {}", import_list));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedModuleImport::ParsedModuleImport(parser::ImportName a_module_name, JaktInternal::Optional<parser::ImportName> a_alias_name, parser::ImportList a_import_list) :module_name(move(a_module_name)), alias_name(move(a_alias_name)), import_list(move(a_import_list)){}
-
-bool parser::ParsedModuleImport::is_equivalent_to(parser::ParsedModuleImport const other) const {
-{
-return ((((((*this).module_name)).equals(((other).module_name))) && (((*this).has_same_alias_than(other)) && ((*this).has_same_import_semantics(other)))));
-}
-}
-
 bool parser::ParsedModuleImport::has_same_alias_than(parser::ParsedModuleImport const other) const {
 {
 if (((((*this).alias_name)).has_value())){
@@ -215,6 +168,8 @@ return ((!(((((other).alias_name)).has_value()))));
 }
 }
 
+parser::ParsedModuleImport::ParsedModuleImport(parser::ImportName a_module_name, JaktInternal::Optional<parser::ImportName> a_alias_name, parser::ImportList a_import_list) :module_name(move(a_module_name)), alias_name(move(a_alias_name)), import_list(move(a_import_list)){}
+
 bool parser::ParsedModuleImport::has_same_import_semantics(parser::ParsedModuleImport const other) const {
 {
 return ((((((*this).import_list)).is_empty()) == ((((other).import_list)).is_empty())));
@@ -304,6 +259,12 @@ if (everything){
 return {};
 }
 
+bool parser::ParsedModuleImport::is_equivalent_to(parser::ParsedModuleImport const other) const {
+{
+return ((((((*this).module_name)).equals(((other).module_name))) && (((*this).has_same_alias_than(other)) && ((*this).has_same_import_semantics(other)))));
+}
+}
+
 ErrorOr<DeprecatedString> parser::ParsedVariable::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedVariable("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
@@ -312,14 +273,14 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedVariable::ParsedVariable(DeprecatedString a_name, NonnullRefPtr<typename parser::ParsedType> a_parsed_type, bool a_is_mutable, utility::Span a_span) :name(move(a_name)), parsed_type(move(a_parsed_type)), is_mutable(move(a_is_mutable)), span(move(a_span)){}
+
 bool parser::ParsedVariable::equals(parser::ParsedVariable const rhs_parsed_varible) const {
 {
 return (((((*this).name) == ((rhs_parsed_varible).name)) && (((((*this).parsed_type))->equals(((rhs_parsed_varible).parsed_type))) && (((*this).is_mutable) == ((rhs_parsed_varible).is_mutable)))));
 }
 }
 
-parser::ParsedVariable::ParsedVariable(DeprecatedString a_name, NonnullRefPtr<typename parser::ParsedType> a_parsed_type, bool a_is_mutable, utility::Span a_span) :name(move(a_name)), parsed_type(move(a_parsed_type)), is_mutable(move(a_is_mutable)), span(move(a_span)){}
-
 ErrorOr<DeprecatedString> parser::ParsedNameWithGenericParameters::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedNameWithGenericParameters("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
@@ -329,152 +290,246 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(builder.append(")"sv));return builder.to_string(); }
 parser::ParsedNameWithGenericParameters::ParsedNameWithGenericParameters(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> a_generic_parameters) :name(move(a_name)), name_span(move(a_name_span)), generic_parameters(move(a_generic_parameters)){}
 
-ErrorOr<DeprecatedString> parser::SumEnumVariant::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("SumEnumVariant("sv));{
+ErrorOr<DeprecatedString> parser::ParsedVarDeclTuple::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedVarDeclTuple("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("var_decls: {}, ", var_decls));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedVarDeclTuple::ParsedVarDeclTuple(JaktInternal::DynamicArray<parser::ParsedVarDecl> a_var_decls, utility::Span a_span) :var_decls(move(a_var_decls)), span(move(a_span)){}
+
+ErrorOr<DeprecatedString> parser::ParsedAttributeArgument::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedAttributeArgument("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("params: {}", params));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("assigned_value: {}", assigned_value));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-parser::SumEnumVariant::SumEnumVariant(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedVarDecl>> a_params) :name(move(a_name)), span(move(a_span)), params(move(a_params)){}
+parser::ParsedAttributeArgument::ParsedAttributeArgument(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<DeprecatedString> a_assigned_value) :name(move(a_name)), span(move(a_span)), assigned_value(move(a_assigned_value)){}
 
-ErrorOr<DeprecatedString> parser::ParsedBlock::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedBlock("sv));{
+ErrorOr<DeprecatedString> parser::ParsedVarDecl::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedVarDecl("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("stmts: {}", stmts));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parsed_type: {}, ", parsed_type));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_mutable: {}, ", is_mutable));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("inlay_span: {}, ", inlay_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-bool parser::ParsedBlock::equals(parser::ParsedBlock const rhs_block) const {
+bool parser::ParsedVarDecl::equals(parser::ParsedVarDecl const rhs_var_decl) const {
 {
-if ((((((*this).stmts)).size()) != ((((rhs_block).stmts)).size()))){
-return (false);
+return (((((*this).name) == ((rhs_var_decl).name)) && (((*this).is_mutable) == ((rhs_var_decl).is_mutable))));
+}
+}
+
+parser::ParsedVarDecl::ParsedVarDecl(DeprecatedString a_name, NonnullRefPtr<typename parser::ParsedType> a_parsed_type, bool a_is_mutable, JaktInternal::Optional<utility::Span> a_inlay_span, utility::Span a_span) :name(move(a_name)), parsed_type(move(a_parsed_type)), is_mutable(move(a_is_mutable)), inlay_span(move(a_inlay_span)), span(move(a_span)){}
+
+ErrorOr<DeprecatedString> parser::ParsedNamespace::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedNamespace("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: {}, ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("functions: {}, ", functions));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("records: {}, ", records));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_trait_implementations: {}, ", external_trait_implementations));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespaces: {}, ", namespaces));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("aliases: {}, ", aliases));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module_imports: {}, ", module_imports));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("extern_imports: {}, ", extern_imports));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("import_path_if_extern: {}, ", import_path_if_extern));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generating_import_extern_before_include: {}, ", generating_import_extern_before_include));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generating_import_extern_after_include: {}", generating_import_extern_after_include));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<void> parser::ParsedNamespace::add_child_namespace(parser::ParsedNamespace const namespace_) {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((*this).stmts)).size()))});
+{
+JaktInternal::ArrayIterator<parser::ParsedNamespace> _magic = ((((*this).namespaces)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedNamespace> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t x = (_magic_value.value());
+parser::ParsedNamespace child_namespace = (_magic_value.value());
 {
-if ((!(((((((*this).stmts))[x]))->equals(((((rhs_block).stmts))[x])))))){
-return (false);
+if (((child_namespace).is_equivalent_to(namespace_))){
+TRY((((child_namespace).merge_with(namespace_))));
+return {};
 }
 }
 
 }
 }
 
-return (true);
+TRY((((((*this).namespaces)).push(namespace_))));
 }
+return {};
 }
 
-parser::ParsedBlock::ParsedBlock(JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> a_stmts) :stmts(move(a_stmts)){}
+parser::ParsedNamespace::ParsedNamespace(JaktInternal::Optional<DeprecatedString> a_name, JaktInternal::Optional<utility::Span> a_name_span, JaktInternal::DynamicArray<parser::ParsedFunction> a_functions, JaktInternal::DynamicArray<parser::ParsedRecord> a_records, JaktInternal::DynamicArray<parser::ParsedTrait> a_traits, JaktInternal::DynamicArray<parser::ParsedExternalTraitImplementation> a_external_trait_implementations, JaktInternal::DynamicArray<parser::ParsedNamespace> a_namespaces, JaktInternal::DynamicArray<parser::ParsedAlias> a_aliases, JaktInternal::DynamicArray<parser::ParsedModuleImport> a_module_imports, JaktInternal::DynamicArray<parser::ParsedExternImport> a_extern_imports, JaktInternal::Optional<DeprecatedString> a_import_path_if_extern, JaktInternal::DynamicArray<parser::IncludeAction> a_generating_import_extern_before_include, JaktInternal::DynamicArray<parser::IncludeAction> a_generating_import_extern_after_include) :name(move(a_name)), name_span(move(a_name_span)), functions(move(a_functions)), records(move(a_records)), traits(move(a_traits)), external_trait_implementations(move(a_external_trait_implementations)), namespaces(move(a_namespaces)), aliases(move(a_aliases)), module_imports(move(a_module_imports)), extern_imports(move(a_extern_imports)), import_path_if_extern(move(a_import_path_if_extern)), generating_import_extern_before_include(move(a_generating_import_extern_before_include)), generating_import_extern_after_include(move(a_generating_import_extern_after_include)){}
 
-JaktInternal::Optional<utility::Span> parser::ParsedBlock::find_yield_span() const {
+bool parser::ParsedNamespace::is_equivalent_to(parser::ParsedNamespace const other) const {
+{
+return (((((*this).name) == ((other).name)) && (((*this).import_path_if_extern) == ((other).import_path_if_extern))));
+}
+}
+
+ErrorOr<void> parser::ParsedNamespace::add_extern_import(parser::ParsedExternImport const import_) {
 {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((*this).stmts)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedExternImport> _magic = ((((*this).extern_imports)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedExternImport> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedStatement> stmt = (_magic_value.value());
+parser::ParsedExternImport extern_import = (_magic_value.value());
 {
-if (((stmt)->index() == 14 /* Yield */)){
-NonnullRefPtr<typename parser::ParsedExpression> const expr = ((stmt)->get<parser::ParsedStatement::Yield>()).expr;
-return (((expr)->span()));
+if (TRY((((extern_import).is_equivalent_to(import_))))){
+TRY((((((extern_import).assigned_namespace)).merge_with(((import_).assigned_namespace)))));
+TRY((((((extern_import).before_include)).push_values(((((import_).before_include)))))));
+TRY((((((extern_import).after_include)).push_values(((((import_).after_include)))))));
+return {};
 }
 }
 
 }
 }
 
-return (JaktInternal::OptionalNone());
+TRY((((((*this).extern_imports)).push(import_))));
 }
+return {};
 }
 
-ErrorOr<JaktInternal::Optional<utility::Span>> parser::ParsedBlock::span(parser::Parser const parser) const {
-{
-JaktInternal::Optional<size_t> start = JaktInternal::OptionalNone();
-size_t end = static_cast<size_t>(0ULL);
+ErrorOr<void> parser::ParsedNamespace::add_alias(parser::ParsedAlias const alias) {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((*this).stmts)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((((*this).aliases)).push(alias))));
 }
-NonnullRefPtr<typename parser::ParsedStatement> stmt = (_magic_value.value());
-{
-utility::Span const stmt_span = ((stmt)->span());
-if ((!(((start).has_value())))){
-(start = ((stmt_span).start));
+return {};
 }
-(end = ((stmt_span).end));
+
+ErrorOr<void> parser::ParsedNamespace::merge_with(parser::ParsedNamespace const namespace_) {
+{
+TRY((((((*this).functions)).push_values(((((namespace_).functions)))))));
+TRY((((((*this).records)).push_values(((((namespace_).records)))))));
+TRY((((((*this).module_imports)).add_capacity(((((namespace_).module_imports)).size())))));
+{
+JaktInternal::ArrayIterator<parser::ParsedModuleImport> _magic = ((((namespace_).module_imports)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedModuleImport> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::ParsedModuleImport import_ = (_magic_value.value());
+{
+TRY((((*this).add_module_import(import_))));
 }
 
 }
 }
 
-if (((start).has_value())){
-return (((parser).span((start.value()),end)));
+TRY((((((*this).extern_imports)).add_capacity(((((namespace_).extern_imports)).size())))));
+{
+JaktInternal::ArrayIterator<parser::ParsedExternImport> _magic = ((((namespace_).extern_imports)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedExternImport> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return (JaktInternal::OptionalNone());
+parser::ParsedExternImport import_ = (_magic_value.value());
+{
+TRY((((*this).add_extern_import(import_))));
+}
+
 }
 }
 
-JaktInternal::Optional<utility::Span> parser::ParsedBlock::find_yield_keyword_span() const {
 {
+JaktInternal::ArrayIterator<parser::ParsedNamespace> _magic = ((((namespace_).namespaces)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedNamespace> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::ParsedNamespace child_namespace = (_magic_value.value());
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((*this).stmts)).iterator());
+TRY((((*this).add_child_namespace(child_namespace))));
+}
+
+}
+}
+
+{
+JaktInternal::ArrayIterator<parser::ParsedAlias> _magic = ((((namespace_).aliases)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedAlias> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedStatement> stmt = (_magic_value.value());
+parser::ParsedAlias alias = (_magic_value.value());
 {
-if (((stmt)->index() == 14 /* Yield */)){
-NonnullRefPtr<typename parser::ParsedExpression> const expr = ((stmt)->get<parser::ParsedStatement::Yield>()).expr;
-return (((stmt)->span()));
+TRY((((*this).add_alias(alias))));
+}
+
 }
 }
 
 }
+return {};
 }
 
-return (JaktInternal::OptionalNone());
+ErrorOr<void> parser::ParsedNamespace::add_module_import(parser::ParsedModuleImport const import_) {
+{
+{
+JaktInternal::ArrayIterator<parser::ParsedModuleImport> _magic = ((((*this).module_imports)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedModuleImport> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::ParsedModuleImport module_import = (_magic_value.value());
+{
+if (((module_import).is_equivalent_to(import_))){
+TRY((((module_import).merge_import_list(((import_).import_list)))));
+return {};
 }
 }
 
-ErrorOr<DeprecatedString> parser::ParsedAttributeArgument::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedAttributeArgument("sv));{
+}
+}
+
+TRY((((((*this).module_imports)).push(import_))));
+}
+return {};
+}
+
+ErrorOr<DeprecatedString> parser::ParsedMethod::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedMethod("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("assigned_value: {}", assigned_value));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parsed_function: {}, ", parsed_function));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("visibility: {}, ", visibility));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_virtual: {}, ", is_virtual));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_override: {}", is_override));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedAttributeArgument::ParsedAttributeArgument(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<DeprecatedString> a_assigned_value) :name(move(a_name)), span(move(a_span)), assigned_value(move(a_assigned_value)){}
+parser::ParsedMethod::ParsedMethod(parser::ParsedFunction a_parsed_function, parser::Visibility a_visibility, bool a_is_virtual, bool a_is_override) :parsed_function(move(a_parsed_function)), visibility(move(a_visibility)), is_virtual(move(a_is_virtual)), is_override(move(a_is_override)){}
 
-ErrorOr<DeprecatedString> parser::ParsedVarDeclTuple::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedVarDeclTuple("sv));{
+ErrorOr<DeprecatedString> parser::ParsedExternalTraitImplementation::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedExternalTraitImplementation("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("var_decls: {}, ", var_decls));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("for_type: {}, ", for_type));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("methods: {}", methods));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedVarDeclTuple::ParsedVarDeclTuple(JaktInternal::DynamicArray<parser::ParsedVarDecl> a_var_decls, utility::Span a_span) :var_decls(move(a_var_decls)), span(move(a_span)){}
+parser::ParsedExternalTraitImplementation::ParsedExternalTraitImplementation(NonnullRefPtr<typename parser::ParsedType> a_for_type, JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> a_traits, JaktInternal::DynamicArray<parser::ParsedMethod> a_methods) :for_type(move(a_for_type)), traits(move(a_traits)), methods(move(a_methods)){}
 
-ErrorOr<DeprecatedString> parser::ParsedAttribute::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedAttribute("sv));{
+ErrorOr<DeprecatedString> parser::ParsedGenericParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedGenericParameter("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("assigned_value: {}, ", assigned_value));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("arguments: {}", arguments));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("requires_list: {}", requires_list));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedAttribute::ParsedAttribute(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<DeprecatedString> a_assigned_value, JaktInternal::DynamicArray<parser::ParsedAttributeArgument> a_arguments) :name(move(a_name)), span(move(a_span)), assigned_value(move(a_assigned_value)), arguments(move(a_arguments)){}
+parser::ParsedGenericParameter::ParsedGenericParameter(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> a_requires_list) :name(move(a_name)), span(move(a_span)), requires_list(move(a_requires_list)){}
 
 ErrorOr<DeprecatedString> parser::ParsedTrait::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedTrait("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
@@ -486,735 +541,712 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(builder.append(")"sv));return builder.to_string(); }
 parser::ParsedTrait::ParsedTrait(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<parser::ParsedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<parser::ParsedFunction> a_methods) :name(move(a_name)), name_span(move(a_name_span)), generic_parameters(move(a_generic_parameters)), methods(move(a_methods)){}
 
-ErrorOr<DeprecatedString> parser::Parser::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Parser("sv));{
+ErrorOr<DeprecatedString> parser::ParsedExternImport::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedExternImport("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("index: {}, ", index));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("tokens: {}, ", tokens));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("can_have_trailing_closure: {}", can_have_trailing_closure));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_c: {}, ", is_c));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("assigned_namespace: {}, ", assigned_namespace));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("before_include: {}, ", before_include));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("after_include: {}", after_include));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parser::Parser::parse_value_enum_body(parser::ParsedRecord const partial_enum,parser::DefinitionLinkage const definition_linkage) {
+ErrorOr<bool> parser::ParsedExternImport::is_equivalent_to(parser::ParsedExternImport const other) const {
 {
-JaktInternal::DynamicArray<parser::ParsedMethod> methods = (TRY((DynamicArray<parser::ParsedMethod>::create_with({}))));
-JaktInternal::DynamicArray<parser::ValueEnumVariant> variants = (TRY((DynamicArray<parser::ValueEnumVariant>::create_with({}))));
-if (((((*this).current())).index() == 9 /* LCurly */)){
-((((*this).index)++));
+return ((((*this).is_c) && (((other).is_c) && ((((*this).get_path()) == ((other).get_path())) && (((*this).get_name()) == ((other).get_name()))))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected `{` to start the enum body"sv),((((*this).current())).span())))));
 }
 
-((*this).skip_newlines());
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected variant name"sv),((((*this).previous())).span())))));
-return ((Tuple{variants, methods}));
+parser::ParsedExternImport::ParsedExternImport(bool a_is_c, parser::ParsedNamespace a_assigned_namespace, JaktInternal::DynamicArray<parser::IncludeAction> a_before_include, JaktInternal::DynamicArray<parser::IncludeAction> a_after_include) :is_c(move(a_is_c)), assigned_namespace(move(a_assigned_namespace)), before_include(move(a_before_include)), after_include(move(a_after_include)){}
+
+DeprecatedString parser::ParsedExternImport::get_path() const {
+{
+return ((((((*this).assigned_namespace)).import_path_if_extern).value()));
 }
-JaktInternal::Optional<parser::Visibility> last_visibility = JaktInternal::OptionalNone();
-JaktInternal::Optional<utility::Span> last_visibility_span = JaktInternal::OptionalNone();
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+}
+
+DeprecatedString parser::ParsedExternImport::get_name() const {
 {
-if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 16 /* Equal */)){
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-TRY((((variants).push(parser::ValueEnumVariant(name,span,expr)))));
+return ((((((*this).assigned_namespace)).name).value()));
 }
-else {
-((((*this).index)++));
-TRY((((variants).push(parser::ValueEnumVariant(name,span,JaktInternal::OptionalNone())))));
 }
 
+ErrorOr<DeprecatedString> parser::ParsedCall::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedCall("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespace_: {}, ", namespace_));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("args: {}, ", args));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_args: {}", type_args));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 10: {
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedCall::ParsedCall(JaktInternal::DynamicArray<DeprecatedString> a_namespace_, DeprecatedString a_name, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> a_args, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> a_type_args) :namespace_(move(a_namespace_)), name(move(a_name)), args(move(a_args)), type_args(move(a_type_args)){}
+
+bool parser::ParsedCall::equals(parser::ParsedCall const rhs_parsed_call) const {
 {
-return JaktInternal::LoopBreak{};
+if ((((*this).name) != ((rhs_parsed_call).name))){
+return (false);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 52: {
-{
-((((*this).index)++));
+if ((((((*this).args)).size()) != ((((rhs_parsed_call).args)).size()))){
+return (false);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 55: {
 {
-((((*this).index)++));
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((*this).args)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 89: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
-utility::Span const& span = __jakt_match_value.value;
+size_t i = (_magic_value.value());
 {
-if (((last_visibility).has_value())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const lhs_str___lhs_expr_ = ((((*this).args))[i]);
+DeprecatedString const lhs_str = ((lhs_str___lhs_expr_).template get<0>());
+utility::Span const _ = ((lhs_str___lhs_expr_).template get<1>());
+NonnullRefPtr<typename parser::ParsedExpression> const lhs_expr = ((lhs_str___lhs_expr_).template get<2>());
+
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const rhs_str____rhs_expr_ = ((((rhs_parsed_call).args))[i]);
+DeprecatedString const rhs_str = ((rhs_str____rhs_expr_).template get<0>());
+utility::Span const __ = ((rhs_str____rhs_expr_).template get<1>());
+NonnullRefPtr<typename parser::ParsedExpression> const rhs_expr = ((rhs_str____rhs_expr_).template get<2>());
+
+if (((lhs_str != rhs_str) || (!(((lhs_expr)->equals(rhs_expr)))))){
+return (false);
 }
-(last_visibility =  parser::Visibility { typename parser::Visibility::Private() } );
-(last_visibility_span = span);
-((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 90: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
-utility::Span const& span = __jakt_match_value.value;
-{
-if (((last_visibility).has_value())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+
 }
-(last_visibility =  parser::Visibility { typename parser::Visibility::Public() } );
-(last_visibility_span = span);
-((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 75: {
-{
-bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
-parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = definition_linkage;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
-TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
+
+return (true);
 }
-parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; });
-(last_visibility = JaktInternal::OptionalNone());
-(last_visibility_span = JaktInternal::OptionalNone());
-parser::ParsedMethod const parsed_method = TRY((((*this).parse_method(function_linkage,visibility,false,false,is_comptime,false))));
-TRY((((methods).push(parsed_method))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 76: {
-{
-bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
-parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = definition_linkage;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
-TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
-}
-parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; });
-(last_visibility = JaktInternal::OptionalNone());
-(last_visibility_span = JaktInternal::OptionalNone());
-parser::ParsedMethod const parsed_method = TRY((((*this).parse_method(function_linkage,visibility,false,false,is_comptime,false))));
-TRY((((methods).push(parsed_method))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or the end of enum block"sv),((((*this).current())).span())))));
-((((*this).index)++));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+
+ErrorOr<DeprecatedString> parser::SumEnumVariant::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("SumEnumVariant("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("params: {}", params));
 }
-if ((!(((((*this).current())).index() == 10 /* RCurly */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Invalid enum definition, expected `}`"sv),((((*this).current())).span())))));
-return ((Tuple{variants, methods}));
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::SumEnumVariant::SumEnumVariant(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedVarDecl>> a_params) :name(move(a_name)), span(move(a_span)), params(move(a_params)){}
+
+ErrorOr<DeprecatedString> parser::VisibilityRestriction::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("VisibilityRestriction("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespace_: {}, ", namespace_));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\"", name));
 }
-((((*this).index)++));
-if (((variants).is_empty())){
-TRY((((*this).error(Jakt::DeprecatedString("Empty enums are not allowed"sv),((partial_enum).name_span)))));
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::VisibilityRestriction::VisibilityRestriction(JaktInternal::DynamicArray<DeprecatedString> a_namespace_, DeprecatedString a_name) :namespace_(move(a_namespace_)), name(move(a_name)){}
+
+ErrorOr<DeprecatedString> parser::ParsedName::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedName("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
 }
-return ((Tuple{variants, methods}));
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedName::ParsedName(DeprecatedString a_name, utility::Span a_span) :name(move(a_name)), span(move(a_span)){}
+
+ErrorOr<DeprecatedString> parser::ParsedField::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedField("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("var_decl: {}, ", var_decl));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("visibility: {}, ", visibility));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("default_value: {}", default_value));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedField::ParsedField(parser::ParsedVarDecl a_var_decl, parser::Visibility a_visibility, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_value) :var_decl(move(a_var_decl)), visibility(move(a_visibility)), default_value(move(a_default_value)){}
+
+ErrorOr<DeprecatedString> parser::ParsedAlias::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedAlias("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("alias_name: {}, ", alias_name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("target: {}", target));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedAlias::ParsedAlias(JaktInternal::Optional<parser::ParsedName> a_alias_name, JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> a_target) :alias_name(move(a_alias_name)), target(move(a_target)){}
 
-ErrorOr<JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>>> parser::Parser::parse_type_parameter_list() {
+ErrorOr<DeprecatedString> parser::Parser::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Parser("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("index: {}, ", index));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("tokens: {}, ", tokens));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("can_have_trailing_closure: {}", can_have_trailing_closure));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_operand_base() {
 {
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> params = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))));
-if (((((*this).current())).index() == 28 /* LessThan */)){
-((((*this).index)++));
-bool saw_ending_bracket = false;
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>>>>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 26: {
-{
-((((*this).index)++));
-(saw_ending_bracket = true);
-return JaktInternal::LoopBreak{};
+case 53: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_5; {
+__jakt_var_5 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("this"sv),span))); goto __jakt_label_3;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_3:; __jakt_var_5.release_value(); }));
 };/*case end*/
-case 33: {
-{
-TRY((((*this).inject_token( lexer::Token { typename lexer::Token::GreaterThan(((((*this).current())).span())) } ))));
+case 101: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_6; {
 ((((*this).index)++));
-(saw_ending_bracket = true);
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
+__jakt_var_6 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 9: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_try_block()))));
 };/*case end*/
 default: {
-{
-size_t index_before = ((*this).index);
-TRY((((params).push(TRY((((*this).parse_typename())))))));
-if ((((*this).index) == index_before)){
-TRY((((*this).error(Jakt::DeprecatedString("Expected type parameter"sv),((((*this).current())).span())))));
-return JaktInternal::LoopBreak{};
-}
-if (((((*this).current())).index() == 52 /* Comma */)){
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_7; {
+NonnullRefPtr<typename parser::ParsedExpression> const expression = TRY((((*this).parse_expression(true,true))));
+JaktInternal::Optional<parser::ParsedBlock> catch_block = JaktInternal::OptionalNone();
+JaktInternal::Optional<DeprecatedString> catch_name = JaktInternal::OptionalNone();
+if (((((*this).current())).index() == 64 /* Catch */)){
+((((*this).index)++));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+(catch_name = name);
 ((((*this).index)++));
 }
+(catch_block = TRY((((*this).parse_block()))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-}
-if ((!(saw_ending_bracket))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected `>` after type parameters"sv),((((*this).current())).span())))));
-}
-}
-return (params);
-}
-}
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parser::Parser::parse_statement(bool const inside_block) {
-{
-utility::Span const start = ((((*this).current())).span());
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedStatement>, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 67: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_5; {
-((((*this).index)++));
-__jakt_var_5 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::InlineCpp>(TRY((((*this).parse_block()))),TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_3;
+__jakt_var_7 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Try>(expression,catch_block,catch_name,span))); goto __jakt_label_5;
 
 }
-__jakt_label_3:; __jakt_var_5.release_value(); }));
+__jakt_label_5:; __jakt_var_7.release_value(); }));
 };/*case end*/
-case 68: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_6; {
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedStatement> const statement = TRY((((*this).parse_statement(false))));
-__jakt_var_6 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Defer>(statement,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_4;
+}/*switch end*/
+}()
+)); goto __jakt_label_4;
 
 }
 __jakt_label_4:; __jakt_var_6.release_value(); }));
 };/*case end*/
-case 102: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_7; {
-((((*this).index)++));
-parser::ParsedBlock const block = TRY((((*this).parse_block())));
-__jakt_var_7 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::UnsafeBlock>(block,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_5;
-
-}
-__jakt_label_5:; __jakt_var_7.release_value(); }));
-};/*case end*/
-case 63: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_8; {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_8; {
 ((((*this).index)++));
-__jakt_var_8 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Break>(start))); goto __jakt_label_6;
+__jakt_var_8 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::QuotedString>(quote,span))); goto __jakt_label_6;
 
 }
 __jakt_label_6:; __jakt_var_8.release_value(); }));
 };/*case end*/
-case 66: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_9; {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
+JaktInternal::Optional<DeprecatedString> const& prefix = __jakt_match_value.prefix;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_9; {
 ((((*this).index)++));
-__jakt_var_9 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Continue>(start))); goto __jakt_label_7;
+__jakt_var_9 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::SingleQuotedString>(quote,prefix,span))); goto __jakt_label_7;
 
 }
 __jakt_label_7:; __jakt_var_9.release_value(); }));
 };/*case end*/
-case 82: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_10; {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();lexer::LiteralPrefix const& prefix = __jakt_match_value.prefix;
+DeprecatedString const& number = __jakt_match_value.number;
+lexer::LiteralSuffix const& suffix = __jakt_match_value.suffix;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).parse_number(prefix,number,suffix,span)))));
+};/*case end*/
+case 100: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_10; {
 ((((*this).index)++));
-parser::ParsedBlock const block = TRY((((*this).parse_block())));
-__jakt_var_10 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Loop>(block,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_8;
+__jakt_var_10 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Boolean>(true,span))); goto __jakt_label_8;
 
 }
 __jakt_label_8:; __jakt_var_10.release_value(); }));
 };/*case end*/
-case 98: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_11; {
+case 73: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_11; {
 ((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-__jakt_var_11 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Throw>(expr,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_9;
+__jakt_var_11 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Boolean>(false,span))); goto __jakt_label_9;
 
 }
 __jakt_label_9:; __jakt_var_11.release_value(); }));
 };/*case end*/
-case 105: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_12; {
+case 97: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_12; {
 ((((*this).index)++));
-bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
-(((*this).can_have_trailing_closure) = false);
-NonnullRefPtr<typename parser::ParsedExpression> const condition = TRY((((*this).parse_expression(false,true))));
-(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
-parser::ParsedBlock const block = TRY((((*this).parse_block())));
-__jakt_var_12 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::While>(condition,block,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_10;
+__jakt_var_12 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("this"sv),span))); goto __jakt_label_10;
 
 }
 __jakt_label_10:; __jakt_var_12.release_value(); }));
 };/*case end*/
-case 106: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_13; {
+case 86: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_13; {
+utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-if ((!(inside_block))){
-TRY((((*this).error(Jakt::DeprecatedString("‘yield’ can only be used inside a block"sv),TRY((parser::merge_spans(start,((expr)->span()))))))));
-}
-__jakt_var_13 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Yield>(expr,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_11;
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
+__jakt_var_13 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::LogicalNot() } ,span))); goto __jakt_label_11;
 
 }
 __jakt_label_11:; __jakt_var_13.release_value(); }));
 };/*case end*/
-case 93: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_14; {
+case 46: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_14; {
+utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
-__jakt_var_14 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedStatement>, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 55: {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(JaktInternal::OptionalNone(),start))));
-};/*case end*/
-case 56: {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(JaktInternal::OptionalNone(),start))));
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(JaktInternal::OptionalNone(),start))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(TRY((((*this).parse_expression(false,false)))),TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
-};/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_12;
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
+__jakt_var_14 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::BitwiseNot() } ,span))); goto __jakt_label_12;
 
 }
 __jakt_label_12:; __jakt_var_14.release_value(); }));
 };/*case end*/
-case 81: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_15; {
-bool const is_mutable = ((((*this).current())).index() == 84 /* Mut */);
+case 95: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_15; {
+utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
-JaktInternal::DynamicArray<parser::ParsedVarDecl> vars = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
-bool is_destructuring_assingment = false;
-DeprecatedString tuple_var_name = Jakt::DeprecatedString(""sv);
-parser::ParsedVarDecl tuple_var_decl = parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),is_mutable,JaktInternal::OptionalNone(),((((*this).current())).span()));
-if (((((*this).current())).index() == 7 /* LParen */)){
-(vars = ((TRY((((*this).parse_destructuring_assignment(is_mutable))))).var_decls));
-{
-JaktInternal::ArrayIterator<parser::ParsedVarDecl> _magic = ((vars).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedVarDecl> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::ParsedVarDecl var = (_magic_value.value());
-{
-(tuple_var_name += ((var).name));
-(tuple_var_name += Jakt::DeprecatedString("_"sv));
-}
-
-}
-}
+NonnullRefPtr<typename parser::ParsedType> const parsed_type = TRY((((*this).parse_typename())));
+utility::Span const span = TRY((parser::merge_spans(start,((parsed_type)->span()))));
+__jakt_var_15 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))), parser::UnaryOperator { typename parser::UnaryOperator::Sizeof(parsed_type) } ,span))); goto __jakt_label_13;
 
-(((tuple_var_decl).name) = tuple_var_name);
-(is_destructuring_assingment = true);
-}
-else {
-(tuple_var_decl = TRY((((*this).parse_variable_declaration(is_mutable)))));
 }
-
-NonnullRefPtr<typename parser::ParsedExpression> const init = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 16: {
+__jakt_label_13:; __jakt_var_15.release_value(); }));
+};/*case end*/
+case 92: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
+utility::Span const& span = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_16; {
+utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
-__jakt_var_16 = TRY((((*this).parse_expression(false,false)))); goto __jakt_label_14;
+NonnullRefPtr<typename parser::ParsedType> const type = TRY((((*this).parse_typename())));
+utility::Span const span = TRY((parser::merge_spans(start,((type)->span()))));
+__jakt_var_16 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Reflect>(type,span))); goto __jakt_label_14;
 
 }
 __jakt_label_14:; __jakt_var_16.release_value(); }));
 };/*case end*/
-default: {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_17; {
-TRY((((*this).error(Jakt::DeprecatedString("Expected initializer"sv),((((*this).current())).span())))));
-__jakt_var_17 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))); goto __jakt_label_15;
+if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 7 /* LParen */)){
+if ((name == Jakt::DeprecatedString("Some"sv))){
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::OptionalSome>(expr,span))));
+}
+JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>((call.value()),span))));
+}
+if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 28 /* LessThan */)){
+(((((*this).compiler))->ignore_parser_errors) = true);
+JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
+(((((*this).compiler))->ignore_parser_errors) = false);
+if ((!(((call).has_value())))){
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto __jakt_enum_value = (name);
+if (__jakt_enum_value == Jakt::DeprecatedString("None"sv)) {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::OptionalNone>(span))));
+}
+else {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(name,span))));
+}
+}()))
+);
+}
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>((call.value()),span))));
+}
+((((*this).index)++));
+if ((name == Jakt::DeprecatedString("None"sv))){
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::OptionalNone>(span))));
+}
+__jakt_var_17 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(name,span))); goto __jakt_label_15;
 
 }
 __jakt_label_15:; __jakt_var_17.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-));
-NonnullRefPtr<typename parser::ParsedStatement> return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(tuple_var_decl,init,TRY((parser::merge_spans(start,((((*this).previous())).span())))))));
-if (is_destructuring_assingment){
-NonnullRefPtr<typename parser::ParsedStatement> const old_return_statement = return_statement;
-(return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::DestructuringAssignment>(vars,old_return_statement,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
-}
-__jakt_var_15 = return_statement; goto __jakt_label_13;
-
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_18; {
+utility::Span const start_span = ((((*this).current())).span());
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> expr = TRY((((*this).parse_expression(false,false))));
+((*this).skip_newlines());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 8: {
+{
+((((*this).index)++));
 }
-__jakt_label_13:; __jakt_var_15.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 84: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_18; {
-bool const is_mutable = ((((*this).current())).index() == 84 /* Mut */);
+case 52: {
+{
 ((((*this).index)++));
-JaktInternal::DynamicArray<parser::ParsedVarDecl> vars = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
-bool is_destructuring_assingment = false;
-DeprecatedString tuple_var_name = Jakt::DeprecatedString(""sv);
-parser::ParsedVarDecl tuple_var_decl = parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),is_mutable,JaktInternal::OptionalNone(),((((*this).current())).span()));
-if (((((*this).current())).index() == 7 /* LParen */)){
-(vars = ((TRY((((*this).parse_destructuring_assignment(is_mutable))))).var_decls));
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> tuple_exprs = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>>::create_with({expr}))));
+utility::Span end_span = start_span;
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 55: {
 {
-JaktInternal::ArrayIterator<parser::ParsedVarDecl> _magic = ((vars).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedVarDecl> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+((((*this).index)++));
 }
-parser::ParsedVarDecl var = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 52: {
 {
-(tuple_var_name += ((var).name));
-(tuple_var_name += Jakt::DeprecatedString("_"sv));
+((((*this).index)++));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 8: {
+{
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+(end_span = ((expr)->span()));
+TRY((((tuple_exprs).push(expr))));
 }
-
-(((tuple_var_decl).name) = tuple_var_name);
-(is_destructuring_assingment = true);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
-else {
-(tuple_var_decl = TRY((((*this).parse_variable_declaration(is_mutable)))));
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ')'"sv),((((*this).current())).span())))));
 }
-
-NonnullRefPtr<typename parser::ParsedExpression> const init = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 16: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_19; {
-((((*this).index)++));
-__jakt_var_19 = TRY((((*this).parse_expression(false,false)))); goto __jakt_label_17;
-
+(expr = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::JaktTuple>(tuple_exprs,TRY((parser::merge_spans(start_span,end_span)))))));
 }
-__jakt_label_17:; __jakt_var_19.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_20; {
-TRY((((*this).error(Jakt::DeprecatedString("Expected initializer"sv),((((*this).current())).span())))));
-__jakt_var_20 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))); goto __jakt_label_18;
-
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected ')'"sv),((((*this).current())).span())))));
 }
-__jakt_label_18:; __jakt_var_20.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-NonnullRefPtr<typename parser::ParsedStatement> return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(tuple_var_decl,init,TRY((parser::merge_spans(start,((((*this).previous())).span())))))));
-if (is_destructuring_assingment){
-NonnullRefPtr<typename parser::ParsedStatement> const old_return_statement = return_statement;
-(return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::DestructuringAssignment>(vars,old_return_statement,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
-}
-__jakt_var_18 = return_statement; goto __jakt_label_16;
+__jakt_var_18 = expr; goto __jakt_label_16;
 
 }
 __jakt_label_16:; __jakt_var_18.release_value(); }));
 };/*case end*/
-case 77: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_if_statement()))));
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_19; {
+parser::UnaryOperator const op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::UnaryOperator, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 18: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreIncrement() } );
 };/*case end*/
-case 74: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_for_statement()))));
+case 20: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreDecrement() } );
 };/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_21; {
-parser::ParsedBlock const block = TRY((((*this).parse_block())));
-__jakt_var_21 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(block,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_19;
+case 15: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::Negate() } );
+};/*case end*/
+default: {
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("unreachable"sv)))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+));
+utility::Span const start = ((((*this).current())).span());
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
+__jakt_var_19 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr,op,span))); goto __jakt_label_17;
 
 }
-__jakt_label_19:; __jakt_var_21.release_value(); }));
+__jakt_label_17:; __jakt_var_19.release_value(); }));
 };/*case end*/
-case 107: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_guard_statement()))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_20; {
+parser::UnaryOperator const op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::UnaryOperator, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 18: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreIncrement() } );
+};/*case end*/
+case 20: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreDecrement() } );
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::Negate() } );
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_22; {
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(true,false))));
-__jakt_var_22 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Expression>(expr,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_20;
-
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("unreachable"sv)))));
 }
-__jakt_label_20:; __jakt_var_22.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
-)));
-}
-}
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_shorthand_array_or_dictionary() {
-{
+));
 utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedType> const inner = TRY((((*this).parse_typename())));
-if (((((*this).current())).index() == 12 /* RSquare */)){
-((((*this).index)++));
-return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::JaktArray>(inner,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
-}
-if (((((*this).current())).index() == 5 /* Colon */)){
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedType> const value = TRY((((*this).parse_typename())));
-if (((((*this).current())).index() == 12 /* RSquare */)){
-((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ']'"sv),((((*this).current())).span())))));
-}
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
+__jakt_var_20 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr,op,span))); goto __jakt_label_18;
 
-return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Dictionary>(inner,value,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
 }
-TRY((((*this).error(Jakt::DeprecatedString("Expected shorthand type"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
-}
-}
-
-ErrorOr<parser::ParsedBlock> parser::Parser::parse_fat_arrow() {
+__jakt_label_18:; __jakt_var_20.release_value(); }));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_21; {
+parser::UnaryOperator const op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::UnaryOperator, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 18: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreIncrement() } );
+};/*case end*/
+case 20: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreDecrement() } );
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::Negate() } );
+};/*case end*/
+default: {
 {
-((((*this).index)++));
-utility::Span const start = ((((*this).current())).span());
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-NonnullRefPtr<typename parser::ParsedStatement> const return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(expr,TRY((parser::merge_spans(start,((((*this).current())).span())))))));
-return (parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({return_statement}))))));
-}
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("unreachable"sv)))));
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_typename() {
-{
+};/*case end*/
+}/*switch end*/
+}()
+));
 utility::Span const start = ((((*this).current())).span());
-bool is_reference = false;
-bool is_mutable_reference = false;
-if (((((*this).current())).index() == 37 /* Ampersand */)){
-(is_reference = true);
 ((((*this).index)++));
-if (((((*this).current())).index() == 84 /* Mut */)){
-(is_mutable_reference = true);
-((((*this).index)++));
-}
-}
-NonnullRefPtr<typename parser::ParsedType> parsed_type = TRY((((*this).parse_type_shorthand())));
-if (((parsed_type)->index() == 13 /* Empty */)){
-(parsed_type = TRY((((*this).parse_type_longhand()))));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
+__jakt_var_21 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr,op,span))); goto __jakt_label_19;
+
 }
-if (((((*this).current())).index() == 49 /* QuestionMark */)){
-((((*this).index)++));
-utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
-(parsed_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Optional>(parsed_type,span))));
+__jakt_label_19:; __jakt_var_21.release_value(); }));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_22; {
+__jakt_var_22 = TRY((((*this).parse_array_or_dictionary_literal()))); goto __jakt_label_20;
+
 }
-if (is_reference){
-utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
-if (is_mutable_reference){
-(parsed_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::MutableReference>(parsed_type,span))));
+__jakt_label_20:; __jakt_var_22.release_value(); }));
+};/*case end*/
+case 83: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_23; {
+__jakt_var_23 = TRY((((*this).parse_match_expression()))); goto __jakt_label_21;
+
 }
-else {
-(parsed_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Reference>(parsed_type,span))));
+__jakt_label_21:; __jakt_var_23.release_value(); }));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_24; {
+__jakt_var_24 = TRY((((*this).parse_set_literal()))); goto __jakt_label_22;
+
 }
+__jakt_label_22:; __jakt_var_24.release_value(); }));
+};/*case end*/
+case 37: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_ampersand()))));
+};/*case end*/
+case 36: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_asterisk()))));
+};/*case end*/
+case 75: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_lambda()))));
+};/*case end*/
+case 54: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_range()))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_25; {
+utility::Span const span = ((((*this).current())).span());
+((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Unsupported expression"sv),span))));
+__jakt_var_25 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))); goto __jakt_label_23;
 
 }
-return (parsed_type);
+__jakt_label_23:; __jakt_var_25.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
-ErrorOr<void> parser::Parser::error_with_hint(DeprecatedString const message,utility::Span const span,DeprecatedString const hint,utility::Span const hint_span) {
+utility::Span parser::Parser::span(size_t const start,size_t const end) const {
 {
-if ((!(((((*this).compiler))->ignore_parser_errors)))){
-TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::MessageWithHint(message,span,hint,hint_span) } ))));
-}
+return (utility::Span((((((*this).compiler))->current_file).value()),start,end));
 }
-return {};
 }
 
-ErrorOr<parser::ParsedRecord> parser::Parser::parse_class(parser::DefinitionLinkage const definition_linkage) {
+ErrorOr<JaktInternal::Optional<parser::NumericConstant>> parser::Parser::make_integer_numeric_constant(u64 const number,lexer::LiteralSuffix const suffix,utility::Span const span) {
 {
-parser::ParsedRecord parsed_class = parser::ParsedRecord(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),definition_linkage,JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedMethod>::create_with({})))), parser::RecordType { typename parser::RecordType::Garbage() } ,JaktInternal::OptionalNone());
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> super_type = JaktInternal::OptionalNone();
-if (((((*this).current())).index() == 65 /* Class */)){
-((((*this).index)++));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<parser::NumericConstant>>>{
+auto&& __jakt_match_variant = suffix;
+switch(__jakt_match_variant.index()) {
+case 0: {
+{
+JaktInternal::Optional<i64> const n = (fallible_integer_cast<i64>((number)));
+if (((n).has_value())){
+return ( parser::NumericConstant { typename parser::NumericConstant::UnknownSigned((n.value())) } );
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected `class` keyword"sv),((((*this).current())).span())))));
-return (parsed_class);
+return ( parser::NumericConstant { typename parser::NumericConstant::UnknownUnsigned(number) } );
 }
-
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected name"sv),((((*this).current())).span())))));
-return (parsed_class);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+{
+JaktInternal::Optional<u8> const n = (fallible_integer_cast<u8>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
 }
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
-((((*this).index)++));
-(((parsed_class).name) = name);
-(((parsed_class).name_span) = span);
+return ( parser::NumericConstant { typename parser::NumericConstant::U8((n.value())) } );
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected name"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+{
+JaktInternal::Optional<u16> const n = (fallible_integer_cast<u16>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
 }
-
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected generic parameters or super class or body"sv),((((*this).current())).span())))));
-return (parsed_class);
+return ( parser::NumericConstant { typename parser::NumericConstant::U16((n.value())) } );
 }
-(((parsed_class).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
-if (((((*this).current())).index() == 108 /* Implements */)){
-((((*this).index)++));
-(((parsed_class).implements_list) = TRY((((*this).parse_trait_list()))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 4: {
+{
+JaktInternal::Optional<u32> const n = (fallible_integer_cast<u32>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
 }
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected super class or body"sv),((((*this).current())).span())))));
-return (parsed_class);
+return ( parser::NumericConstant { typename parser::NumericConstant::U32((n.value())) } );
 }
-if (((((*this).current())).index() == 5 /* Colon */)){
-((((*this).index)++));
-(super_type = TRY((((*this).parse_typename()))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 5: {
+{
+JaktInternal::Optional<u64> const n = (fallible_integer_cast<u64>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
 }
-((*this).skip_newlines());
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected body"sv),((((*this).current())).span())))));
-return (parsed_class);
+return ( parser::NumericConstant { typename parser::NumericConstant::U64((n.value())) } );
 }
-JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>> const fields_methods_ = TRY((((*this).parse_struct_class_body(definition_linkage, parser::Visibility { typename parser::Visibility::Private() } ,true))));
-JaktInternal::DynamicArray<parser::ParsedField> const fields = ((fields_methods_).template get<0>());
-JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((fields_methods_).template get<1>());
-
-(((parsed_class).methods) = methods);
-(((parsed_class).record_type) =  parser::RecordType { typename parser::RecordType::Class(fields,super_type) } );
-return (parsed_class);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+{
+JaktInternal::Optional<size_t> const n = (fallible_integer_cast<size_t>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
 }
+return ( parser::NumericConstant { typename parser::NumericConstant::USize((infallible_integer_cast<u64>(((n.value()))))) } );
 }
-
-bool parser::Parser::eof() const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 6: {
 {
-return ((((*this).index) >= (JaktInternal::checked_sub<size_t>(((((*this).tokens)).size()),static_cast<size_t>(1ULL)))));
+JaktInternal::Optional<i8> const n = (fallible_integer_cast<i8>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
 }
+return ( parser::NumericConstant { typename parser::NumericConstant::I8((n.value())) } );
 }
-
-ErrorOr<parser::ParsedVarDeclTuple> parser::Parser::parse_destructuring_assignment(bool const is_mutable) {
-{
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-JaktInternal::DynamicArray<parser::ParsedVarDecl> var_declarations = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
-for (;;){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedVarDeclTuple>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 7: {
 {
-TRY((((var_declarations).push(TRY((((*this).parse_variable_declaration(is_mutable))))))));
+JaktInternal::Optional<i16> const n = (fallible_integer_cast<i16>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
+}
+return ( parser::NumericConstant { typename parser::NumericConstant::I16((n.value())) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 8: {
 {
-((((*this).index)++));
+JaktInternal::Optional<i32> const n = (fallible_integer_cast<i32>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
+}
+return ( parser::NumericConstant { typename parser::NumericConstant::I32((n.value())) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 8: {
+case 9: {
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+JaktInternal::Optional<i64> const n = (fallible_integer_cast<i64>((number)));
+if ((!(((n).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
+return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
+}
+return ( parser::NumericConstant { typename parser::NumericConstant::I64((n.value())) } );
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected close of destructuring assignment block"sv),((((*this).current())).span())))));
-(var_declarations = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({})))));
-return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-}
-return (parser::ParsedVarDeclTuple(var_declarations,TRY((parser::merge_spans(start,((((*this).previous())).span()))))));
+return (JaktInternal::OptionalNone());
 }
 }
 
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_match_expression() {
-{
-utility::Span start = ((((*this).current())).span());
-((((*this).index)++));
-bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
-(((*this).can_have_trailing_closure) = false);
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,true))));
-(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
-JaktInternal::DynamicArray<parser::ParsedMatchCase> const cases = TRY((((*this).parse_match_cases())));
-if ((((cases).size()) > static_cast<size_t>(1ULL))){
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>((JaktInternal::checked_sub<size_t>(((cases).size()),static_cast<size_t>(1ULL))))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>((JaktInternal::checked_add<size_t>(i,static_cast<size_t>(1ULL)))),static_cast<size_t>(((cases).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t k = (_magic_value.value());
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_shorthand() {
 {
-if (((((cases)[i])).has_equal_pattern(((cases)[k])))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Duplicated match pattern"sv),((((cases)[k])).marker_span),Jakt::DeprecatedString("Original pattern here"sv),((((cases)[i])).marker_span)))));
-}
-}
-
-}
-}
-
-}
-
-}
-}
-
-}
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Match>(expr,cases,TRY((parser::merge_spans(start,((((*this).previous())).span())))),start))));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, ErrorOr<NonnullRefPtr<typename parser::ParsedType>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 11: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_type_shorthand_array_or_dictionary()))));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_type_shorthand_set()))));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_type_shorthand_tuple()))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
@@ -1232,12 +1264,12 @@ NonnullRefPtr<typename parser::ParsedType> return_type = JAKT_RESOLVE_EXPLICIT_V
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
 case 58: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_23; {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_26; {
 ((((*this).index)++));
-__jakt_var_23 = TRY((((*this).parse_typename()))); goto __jakt_label_21;
+__jakt_var_26 = TRY((((*this).parse_typename()))); goto __jakt_label_24;
 
 }
-__jakt_label_21:; __jakt_var_23.release_value(); }));
+__jakt_label_24:; __jakt_var_26.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
@@ -1250,15 +1282,15 @@ parser::ParsedBlock const block = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RE
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
 case 57: {
-return JaktInternal::ExplicitValue(({ Optional<parser::ParsedBlock> __jakt_var_24; {
+return JaktInternal::ExplicitValue(({ Optional<parser::ParsedBlock> __jakt_var_27; {
 (is_fat_arrow = true);
 ((((*this).index)++));
 NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(true,false))));
 utility::Span const span = ((expr)->span());
-__jakt_var_24 = parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(expr,span)))}))))); goto __jakt_label_22;
+__jakt_var_27 = parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(expr,span)))}))))); goto __jakt_label_25;
 
 }
-__jakt_label_22:; __jakt_var_24.release_value(); }));
+__jakt_label_25:; __jakt_var_27.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(TRY((((*this).parse_block()))));
@@ -1270,81 +1302,18 @@ return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::P
 }
 }
 
-lexer::Token parser::Parser::previous() const {
-{
-if (((((*this).index) == static_cast<size_t>(0ULL)) || (((*this).index) > ((((*this).tokens)).size())))){
-return ( lexer::Token { typename lexer::Token::Eof(((*this).span(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)))) } );
-}
-return (((((*this).tokens))[(JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL)))]));
-}
-}
-
-ErrorOr<parser::ParsedBlock> parser::Parser::parse_block() {
-{
-utility::Span const start = ((((*this).current())).span());
-parser::ParsedBlock block = parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({})))));
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete block"sv),start))));
-return (block);
-}
-((*this).skip_newlines());
-if (((((*this).current())).index() == 9 /* LCurly */)){
-((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '{'"sv),start))));
-}
-
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedBlock>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 10: {
-{
-((((*this).index)++));
-return (block);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 4: {
-{
-((((*this).index)++));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 55: {
-{
-((((*this).index)++));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-TRY((((((block).stmts)).push(TRY((((*this).parse_statement(true))))))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-}
-TRY((((*this).error(Jakt::DeprecatedString("Expected complete block"sv),((((*this).current())).span())))));
-return (block);
-}
-}
-
 ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_longhand() {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, ErrorOr<NonnullRefPtr<typename parser::ParsedType>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
 case 91: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_25; {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_28; {
 utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
 NonnullRefPtr<typename parser::ParsedType> const inner = TRY((((*this).parse_typename())));
 utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
-__jakt_var_25 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, ErrorOr<NonnullRefPtr<typename parser::ParsedType>>>{
+__jakt_var_28 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, ErrorOr<NonnullRefPtr<typename parser::ParsedType>>>{
 auto&& __jakt_match_variant = *inner;
 switch(__jakt_match_variant.index()) {
 case 7: {
@@ -1356,18 +1325,18 @@ return JaktInternal::ExplicitValue(TRY((parser::ParsedType::template __jakt_crea
 };/*case end*/
 }/*switch end*/
 }()
-)); goto __jakt_label_23;
+)); goto __jakt_label_26;
 
 }
-__jakt_label_23:; __jakt_var_25.release_value(); }));
+__jakt_label_26:; __jakt_var_28.release_value(); }));
 };/*case end*/
 case 104: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_26; {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_29; {
 utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
 NonnullRefPtr<typename parser::ParsedType> const inner = TRY((((*this).parse_typename())));
 utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
-__jakt_var_26 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, ErrorOr<NonnullRefPtr<typename parser::ParsedType>>>{
+__jakt_var_29 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, ErrorOr<NonnullRefPtr<typename parser::ParsedType>>>{
 auto&& __jakt_match_variant = *inner;
 switch(__jakt_match_variant.index()) {
 case 7: {
@@ -1375,23 +1344,23 @@ auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType
 return JaktInternal::ExplicitValue(TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::WeakPtr>(inner,span))));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_27; {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_30; {
 TRY((((*this).error(Jakt::DeprecatedString("missing `?` after weak pointer type name"sv),span))));
-__jakt_var_27 = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::WeakPtr>(inner,span))); goto __jakt_label_25;
+__jakt_var_30 = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::WeakPtr>(inner,span))); goto __jakt_label_28;
 
 }
-__jakt_label_25:; __jakt_var_27.release_value(); }));
+__jakt_label_28:; __jakt_var_30.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
-)); goto __jakt_label_24;
+)); goto __jakt_label_27;
 
 }
-__jakt_label_24:; __jakt_var_26.release_value(); }));
+__jakt_label_27:; __jakt_var_29.release_value(); }));
 };/*case end*/
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_28; {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_31; {
 utility::Span const span = ((((*this).current())).span());
 ((((*this).index)++));
 NonnullRefPtr<typename parser::ParsedType> parsed_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Name>(name,span)));
@@ -1448,13 +1417,13 @@ DeprecatedString const type_name = (((namespaces).pop()).value());
 JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> params = TRY((((*this).parse_type_parameter_list())));
 (parsed_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::NamespacedName>(type_name,namespaces,params,((((*this).previous())).span())))));
 }
-__jakt_var_28 = parsed_type; goto __jakt_label_26;
+__jakt_var_31 = parsed_type; goto __jakt_label_29;
 
 }
-__jakt_label_26:; __jakt_var_28.release_value(); }));
+__jakt_label_29:; __jakt_var_31.release_value(); }));
 };/*case end*/
 case 75: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_29; {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_32; {
 utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
 JaktInternal::DynamicArray<parser::ParsedParameter> const params = TRY((((*this).parse_function_parameters())));
@@ -1471,18 +1440,18 @@ else {
 TRY((((*this).error(Jakt::DeprecatedString("Expected '->'"sv),((((*this).current())).span())))));
 }
 
-__jakt_var_29 = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Function>(params,can_throw,return_type,TRY((parser::merge_spans(start,((return_type)->span()))))))); goto __jakt_label_27;
+__jakt_var_32 = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Function>(params,can_throw,return_type,TRY((parser::merge_spans(start,((return_type)->span()))))))); goto __jakt_label_30;
 
 }
-__jakt_label_27:; __jakt_var_29.release_value(); }));
+__jakt_label_30:; __jakt_var_32.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_30; {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedType>> __jakt_var_33; {
 TRY((((*this).error(Jakt::DeprecatedString("Expected type name"sv),((((*this).current())).span())))));
-__jakt_var_30 = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())); goto __jakt_label_28;
+__jakt_var_33 = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())); goto __jakt_label_31;
 
 }
-__jakt_label_28:; __jakt_var_30.release_value(); }));
+__jakt_label_31:; __jakt_var_33.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
@@ -1490,145 +1459,102 @@ __jakt_label_28:; __jakt_var_30.release_value(); }));
 }
 }
 
-ErrorOr<void> parser::Parser::parse_attribute_list(JaktInternal::DynamicArray<parser::ParsedAttribute>& active_attributes) {
+ErrorOr<parser::ParsedAlias> parser::Parser::parse_using() {
 {
-while ((((!(((*this).eof()))) && (!(((((*this).current())).index() == 12 /* RSquare */)))) && (!(((((*this).peek(static_cast<size_t>(1ULL)))).index() == 12 /* RSquare */))))){
-JaktInternal::Optional<parser::ParsedAttribute> const attribute = TRY((((*this).parse_attribute())));
-if (((attribute).has_value())){
-TRY((((((active_attributes))).push((attribute.value())))));
-}
-}
-if ((((((*this).current())).index() == 12 /* RSquare */) && ((((*this).peek(static_cast<size_t>(1ULL)))).index() == 12 /* RSquare */))){
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]]’"sv),((((*this).current())).span())))));
+parser::ParsedAlias alias = parser::ParsedAlias(JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedNameWithGenericParameters>::create_with({})))));
+for (;;){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedAlias>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 55: {
+{
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 61: {
+{
+return JaktInternal::LoopBreak{};
 }
-return {};
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 56: {
+{
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<void> parser::Parser::error(DeprecatedString const message,utility::Span const span) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 6: {
 {
-if ((!(((((*this).compiler))->ignore_parser_errors)))){
-TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::Message(message,span) } ))));
+((((*this).index)++));
+return JaktInternal::LoopContinue{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+{
+parser::ParsedNameWithGenericParameters parsed_name = parser::ParsedNameWithGenericParameters(name,span,(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({})))));
+((((*this).index)++));
+if (((((*this).current())).index() == 28 /* LessThan */)){
+((((*this).index)++));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedAlias>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 26: {
+{
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
-return {};
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 52: {
+{
+((((*this).index)++));
 }
-
-ErrorOr<parser::ParsedRecord> parser::Parser::parse_struct(parser::DefinitionLinkage const definition_linkage) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 55: {
 {
-parser::ParsedRecord parsed_struct = parser::ParsedRecord(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),definition_linkage,JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedMethod>::create_with({})))), parser::RecordType { typename parser::RecordType::Garbage() } ,JaktInternal::OptionalNone());
-if (((((*this).current())).index() == 96 /* Struct */)){
 ((((*this).index)++));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected `struct` keyword"sv),((((*this).current())).span())))));
-return (parsed_struct);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 33: {
+{
+TRY((((*this).inject_token( lexer::Token { typename lexer::Token::GreaterThan(((((*this).current())).span())) } ))));
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+return JaktInternal::LoopBreak{};
 }
-
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct definition, expected name"sv),((((*this).current())).span())))));
-return (parsed_struct);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+size_t const index_before = ((*this).index);
+NonnullRefPtr<typename parser::ParsedType> const inner_type = TRY((((*this).parse_typename())));
+if ((index_before == ((*this).index))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected type name"sv),((((*this).current())).span())))));
+return JaktInternal::LoopBreak{};
 }
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
-((((*this).index)++));
-(((parsed_struct).name) = name);
-(((parsed_struct).name_span) = span);
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct definition, expected name"sv),((((*this).current())).span())))));
-}
-
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct definition, expected generic parameters or body"sv),((((*this).current())).span())))));
-return (parsed_struct);
-}
-(((parsed_struct).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
-if (((((*this).current())).index() == 108 /* Implements */)){
-((((*this).index)++));
-(((parsed_struct).implements_list) = TRY((((*this).parse_trait_list()))));
-}
-((*this).skip_newlines());
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct definition, expected body"sv),((((*this).current())).span())))));
-return (parsed_struct);
-}
-JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>> const fields_methods_ = TRY((((*this).parse_struct_class_body(definition_linkage, parser::Visibility { typename parser::Visibility::Public() } ,false))));
-JaktInternal::DynamicArray<parser::ParsedField> const fields = ((fields_methods_).template get<0>());
-JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((fields_methods_).template get<1>());
-
-(((parsed_struct).methods) = methods);
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const super_type = JaktInternal::OptionalNone();
-(((parsed_struct).record_type) =  parser::RecordType { typename parser::RecordType::Struct(fields,super_type) } );
-return (parsed_struct);
-}
-}
-
-bool parser::Parser::eol() const {
-{
-return ((((*this).eof()) || ((((((*this).tokens))[((*this).index)])).index() == 55 /* Eol */)));
-}
-}
-
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>>> parser::Parser::parse_trait_list() {
-{
-if (((((*this).current())).index() == 7 /* LParen */)){
-((((*this).index)++));
-JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> result = (TRY((DynamicArray<parser::ParsedNameWithGenericParameters>::create_with({}))));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 55: {
-{
-((((*this).index)++));
-return JaktInternal::LoopContinue{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 52: {
-{
-((((*this).index)++));
-return JaktInternal::LoopContinue{};
+TRY((((((parsed_name).generic_parameters)).push(inner_type))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 56: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Eof>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected ')' to close the trait list"sv),span))));
-return JaktInternal::LoopBreak{};
+}/*switch end*/
+}()
+));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 8: {
-{
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-{
-parser::ParsedNameWithGenericParameters parsed_name = parser::ParsedNameWithGenericParameters(name,span,(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({})))));
-((((*this).index)++));
-(((parsed_name).generic_parameters) = TRY((((*this).parse_type_parameter_list()))));
-TRY((((result).push(parsed_name))));
+TRY((((((alias).target)).push(parsed_name))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 0: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1636,7 +1562,7 @@ return JaktInternal::ExplicitValue<void>();
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1644,7 +1570,7 @@ return JaktInternal::ExplicitValue<void>();
 case 2: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1653,7 +1579,7 @@ case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Semicolon>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1662,25 +1588,25 @@ case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Colon>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ColonColon>();
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RParen>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1689,7 +1615,7 @@ case 9: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LCurly>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1698,7 +1624,7 @@ case 10: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RCurly>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1707,7 +1633,7 @@ case 11: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LSquare>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1716,7 +1642,7 @@ case 12: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RSquare>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1725,7 +1651,7 @@ case 13: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSign>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1734,7 +1660,7 @@ case 14: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Plus>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1743,7 +1669,7 @@ case 15: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1752,7 +1678,7 @@ case 16: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Equal>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1761,7 +1687,7 @@ case 17: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1770,7 +1696,7 @@ case 18: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1779,7 +1705,7 @@ case 19: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1788,7 +1714,7 @@ case 20: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1797,7 +1723,7 @@ case 21: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AsteriskEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1806,7 +1732,7 @@ case 22: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlashEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1815,7 +1741,7 @@ case 23: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSignEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1824,7 +1750,7 @@ case 24: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::NotEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1833,7 +1759,7 @@ case 25: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DoubleEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1842,7 +1768,7 @@ case 26: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThan>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1851,7 +1777,7 @@ case 27: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThanOrEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1860,7 +1786,7 @@ case 28: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThan>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1869,7 +1795,7 @@ case 29: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThanOrEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1878,7 +1804,7 @@ case 30: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftArithmeticShift>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1887,7 +1813,7 @@ case 31: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShift>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1896,7 +1822,7 @@ case 32: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShiftEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1905,7 +1831,7 @@ case 33: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShift>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1914,7 +1840,7 @@ case 34: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightArithmeticShift>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1923,7 +1849,7 @@ case 35: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShiftEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1932,7 +1858,7 @@ case 36: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Asterisk>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1941,7 +1867,7 @@ case 37: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Ampersand>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1950,7 +1876,7 @@ case 38: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1959,7 +1885,7 @@ case 39: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandAmpersand>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1968,7 +1894,7 @@ case 40: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Pipe>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1977,7 +1903,7 @@ case 41: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipeEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1986,7 +1912,7 @@ case 42: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipePipe>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -1995,7 +1921,7 @@ case 43: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Caret>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2004,7 +1930,7 @@ case 44: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::CaretEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2013,7 +1939,7 @@ case 45: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dollar>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2022,7 +1948,7 @@ case 46: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2031,7 +1957,7 @@ case 47: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlash>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2040,7 +1966,7 @@ case 48: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ExclamationPoint>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2049,7 +1975,7 @@ case 49: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMark>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2058,7 +1984,7 @@ case 50: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMark>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2067,7 +1993,16 @@ case 51: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMarkEqual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 52: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comma>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2076,7 +2011,7 @@ case 53: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2085,7 +2020,7 @@ case 54: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DotDot>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2094,7 +2029,7 @@ case 57: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::FatArrow>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2103,7 +2038,7 @@ case 58: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Arrow>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2112,7 +2047,7 @@ case 59: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::And>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2121,16 +2056,7 @@ case 60: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Anon>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 61: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::As>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2139,7 +2065,7 @@ case 62: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Boxed>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2148,7 +2074,7 @@ case 63: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Break>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2157,7 +2083,7 @@ case 64: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Catch>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2166,7 +2092,7 @@ case 65: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Class>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2175,7 +2101,7 @@ case 66: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Continue>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2184,7 +2110,7 @@ case 67: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Cpp>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2193,7 +2119,7 @@ case 68: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Defer>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2202,7 +2128,7 @@ case 69: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Destructor>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2211,7 +2137,7 @@ case 70: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Else>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2220,7 +2146,7 @@ case 71: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Enum>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2229,7 +2155,7 @@ case 72: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Extern>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2238,7 +2164,7 @@ case 73: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2247,7 +2173,7 @@ case 74: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::For>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2256,7 +2182,7 @@ case 75: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Fn>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2265,7 +2191,7 @@ case 76: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comptime>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2274,7 +2200,7 @@ case 77: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::If>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2283,7 +2209,7 @@ case 78: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Import>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2292,7 +2218,7 @@ case 79: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::In>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2301,7 +2227,7 @@ case 80: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Is>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2310,7 +2236,7 @@ case 81: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Let>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2319,7 +2245,7 @@ case 82: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Loop>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2328,7 +2254,7 @@ case 83: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Match>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2337,7 +2263,7 @@ case 84: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Mut>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2346,7 +2272,7 @@ case 85: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Namespace>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2355,7 +2281,7 @@ case 86: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2364,7 +2290,7 @@ case 87: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Or>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2373,7 +2299,7 @@ case 88: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Override>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2382,7 +2308,7 @@ case 89: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2391,7 +2317,7 @@ case 90: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2400,7 +2326,7 @@ case 91: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Raw>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2409,7 +2335,7 @@ case 92: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2418,7 +2344,7 @@ case 93: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Return>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2427,7 +2353,7 @@ case 94: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2436,7 +2362,7 @@ case 95: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2445,7 +2371,7 @@ case 96: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Struct>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2454,7 +2380,7 @@ case 97: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2463,7 +2389,7 @@ case 98: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throw>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2472,7 +2398,7 @@ case 99: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throws>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2481,7 +2407,7 @@ case 100: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2490,7 +2416,7 @@ case 101: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2499,7 +2425,7 @@ case 102: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Unsafe>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2508,7 +2434,7 @@ case 103: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Virtual>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2517,7 +2443,7 @@ case 104: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Weak>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2526,7 +2452,7 @@ case 105: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::While>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2535,7 +2461,7 @@ case 106: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Yield>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2544,7 +2470,7 @@ case 107: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Guard>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2553,7 +2479,7 @@ case 108: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Implements>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2562,7 +2488,7 @@ case 109: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Requires>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2571,7 +2497,7 @@ case 110: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Trait>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2579,7 +2505,7 @@ return JaktInternal::ExplicitValue<void>();
 case 111: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Garbage>();utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
@@ -2588,3172 +2514,2966 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
 }
-if (((result).is_empty())){
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait list to have at least one trait inside it"sv),((((*this).previous())).span())))));
-return (JaktInternal::OptionalNone());
-}
-else {
-return (static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>>>(result));
-}
-
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '(' to start the trait list"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
-}
-
-}
+if (((((*this).previous())).index() == 6 /* ColonColon */)){
+utility::Span const span = ((((*this).previous())).get<lexer::Token::ColonColon>()).value;
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 }
-
-ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parser::Parser::parse_struct_class_body(parser::DefinitionLinkage const definition_linkage,parser::Visibility const default_visibility,bool const is_class) {
-{
-if (((((*this).current())).index() == 9 /* LCurly */)){
+if (((((*this).current())).index() == 61 /* As */)){
 ((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
-}
-
-JaktInternal::DynamicArray<parser::ParsedField> fields = (TRY((DynamicArray<parser::ParsedField>::create_with({}))));
-JaktInternal::DynamicArray<parser::ParsedMethod> methods = (TRY((DynamicArray<parser::ParsedMethod>::create_with({}))));
-JaktInternal::Optional<parser::Visibility> last_visibility = JaktInternal::OptionalNone();
-JaktInternal::Optional<utility::Span> last_visibility_span = JaktInternal::OptionalNone();
-bool last_virtual = false;
-bool last_override = false;
-bool error = false;
-JaktInternal::DynamicArray<parser::ParsedAttribute> active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({}))));
-while ((!(((*this).eof())))){
-lexer::Token const token = ((*this).current());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = token;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedAlias>>{
+auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 10: {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
-if (((last_visibility).has_value())){
-TRY((((*this).error(Jakt::DeprecatedString("Expected function or parameter after visibility modifier"sv),((token).span())))));
+(((alias).alias_name) = parser::ParsedName(name,span));
+((((*this).index)++));
 }
-if ((!(((active_attributes).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected function after attribute"sv),((token).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-((((*this).index)++));
-return ((Tuple{fields, methods}));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();utility::Span const& span = __jakt_match_value.span;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();utility::Span const& span = __jakt_match_value.span;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Semicolon>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 90: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Colon>();
 utility::Span const& span = __jakt_match_value.value;
 {
-if (((last_visibility).has_value())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-(last_visibility =  parser::Visibility { typename parser::Visibility::Public() } );
-(last_visibility_span = span);
-((((*this).index)++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ColonColon>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 89: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
 utility::Span const& span = __jakt_match_value.value;
 {
-if (((last_visibility).has_value())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-(last_visibility =  parser::Visibility { typename parser::Visibility::Private() } );
-(last_visibility_span = span);
-((((*this).index)++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RParen>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 94: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LCurly>();
 utility::Span const& span = __jakt_match_value.value;
 {
-if (((last_visibility).has_value())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-(last_visibility = TRY((((*this).parse_restricted_visibility_modifier()))));
-(last_visibility_span = span);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RCurly>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LSquare>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 11 /* LSquare */)){
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
-TRY((((*this).parse_attribute_list(((active_attributes))))));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Unexpected token (expected ‘[[’)"sv),((((*this).current())).span())))));
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RSquare>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSign>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((!(((active_attributes).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Attributes cannot be applied to fields"sv),((((*this).current())).span())))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return default_visibility; });
-(last_visibility = JaktInternal::OptionalNone());
-(last_visibility_span = JaktInternal::OptionalNone());
-if ((last_virtual || last_override)){
-TRY((((*this).error(Jakt::DeprecatedString("Fields cannot be ‘virtual’ or ‘override’"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Plus>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-(last_virtual = false);
-(last_override = false);
-parser::ParsedField const field = TRY((((*this).parse_field(visibility))));
-TRY((((fields).push(field))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 75: {
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Equal>();
+utility::Span const& span = __jakt_match_value.value;
 {
-bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
-bool const is_destructor = ((((*this).current())).index() == 69 /* Destructor */);
-parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = definition_linkage;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
-TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
-}
-parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return default_visibility; });
-(last_visibility = JaktInternal::OptionalNone());
-(last_visibility_span = JaktInternal::OptionalNone());
-bool const is_virtual = last_virtual;
-bool const is_override = last_override;
-(last_virtual = false);
-(last_override = false);
-parser::ParsedMethod parsed_method = TRY((((*this).parse_method(function_linkage,visibility,is_virtual,is_override,is_comptime,is_destructor))));
-TRY((((*this).apply_attributes(((parsed_method)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((methods).push(parsed_method))));
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 76: {
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
+utility::Span const& span = __jakt_match_value.value;
 {
-bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
-bool const is_destructor = ((((*this).current())).index() == 69 /* Destructor */);
-parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = definition_linkage;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
-TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
-}
-parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return default_visibility; });
-(last_visibility = JaktInternal::OptionalNone());
-(last_visibility_span = JaktInternal::OptionalNone());
-bool const is_virtual = last_virtual;
-bool const is_override = last_override;
-(last_virtual = false);
-(last_override = false);
-parser::ParsedMethod parsed_method = TRY((((*this).parse_method(function_linkage,visibility,is_virtual,is_override,is_comptime,is_destructor))));
-TRY((((*this).apply_attributes(((parsed_method)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((methods).push(parsed_method))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 69: {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
-bool const is_destructor = ((((*this).current())).index() == 69 /* Destructor */);
-parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = definition_linkage;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
-TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
-}
-parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return default_visibility; });
-(last_visibility = JaktInternal::OptionalNone());
-(last_visibility_span = JaktInternal::OptionalNone());
-bool const is_virtual = last_virtual;
-bool const is_override = last_override;
-(last_virtual = false);
-(last_override = false);
-parser::ParsedMethod parsed_method = TRY((((*this).parse_method(function_linkage,visibility,is_virtual,is_override,is_comptime,is_destructor))));
-TRY((((*this).apply_attributes(((parsed_method)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((methods).push(parsed_method))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 103: {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
+utility::Span const& span = __jakt_match_value.value;
 {
-(last_virtual = true);
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 88: {
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AsteriskEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-(last_override = true);
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlashEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-if ((!(error))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid member, did not expect a {} here"sv),token))),((token).span())))));
-(error = true);
-}
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-if (is_class){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete class body, expected ‘}’"sv),((((*this).current())).span())))));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct body, expected ‘}’"sv),((((*this).current())).span())))));
-}
-
-return ((Tuple{fields, methods}));
-}
-}
-
-ErrorOr<JaktInternal::DynamicArray<parser::EnumVariantPatternArgument>> parser::Parser::parse_variant_arguments() {
-{
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments = (TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({}))));
-bool has_parens = false;
-if (((((*this).current())).index() == 7 /* LParen */)){
-(has_parens = true);
-((((*this).index)++));
-bool is_reference = false;
-bool is_mutable = false;
-while ((!(((*this).eof())))){
-((*this).skip_newlines());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::EnumVariantPatternArgument>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 37: {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSignEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-(is_reference = true);
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 84: {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::NotEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-(is_mutable = true);
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& arg_name = __jakt_match_value.name;
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DoubleEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 5 /* Colon */)){
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const arg_binding = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).span());
-((((*this).index)++));
-TRY((((variant_arguments).push(parser::EnumVariantPatternArgument(static_cast<JaktInternal::Optional<DeprecatedString>>(arg_name),arg_binding,span,is_reference,is_mutable)))));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected binding after ‘:’"sv),((((*this).current())).span())))));
-}
-
-}
-else {
-TRY((((variant_arguments).push(parser::EnumVariantPatternArgument(JaktInternal::OptionalNone(),arg_name,((((*this).current())).span()),is_reference,is_mutable)))));
-((((*this).index)++));
-}
-
-(is_reference = false);
-(is_mutable = false);
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThan>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 8: {
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThanOrEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThan>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected pattern argument name"sv),((((*this).current())).span())))));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-}
-return (variant_arguments);
-}
-}
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_set_literal() {
-{
-utility::Span const start = ((((*this).current())).span());
-if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))));
-}
-((((*this).index)++));
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> output = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>>::create_with({}))));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 10: {
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThanOrEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 30: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftArithmeticShift>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 31: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShift>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 32: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShiftEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-if (((expr)->index() == 29 /* Garbage */)){
-return JaktInternal::LoopBreak{};
-}
-TRY((((output).push(expr))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-size_t const end = (JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL)));
-if (((end >= ((((*this).tokens)).size())) || (!(((((((*this).tokens))[end])).index() == 10 /* RCurly */))))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘}’ to close the set"sv),((((((*this).tokens))[end])).span())))));
-}
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Set>(output,TRY((parser::merge_spans(start,((((((*this).tokens))[end])).span()))))))));
-}
-}
-
-ErrorOr<parser::ParsedField> parser::Parser::parse_field(parser::Visibility const visibility) {
+case 33: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShift>();
+utility::Span const& span = __jakt_match_value.value;
 {
-parser::ParsedVarDecl const parsed_variable_declaration = TRY((((*this).parse_variable_declaration(true))));
-if (((((parsed_variable_declaration).parsed_type))->index() == 13 /* Empty */)){
-TRY((((*this).error(Jakt::DeprecatedString("Field missing type"sv),((parsed_variable_declaration).span)))));
-}
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_value = JaktInternal::OptionalNone();
-if (((((*this).peek(static_cast<size_t>(0ULL)))).index() == 16 /* Equal */)){
-((((*this).index)++));
-(default_value = TRY((((*this).parse_expression(false,false)))));
-}
-return (parser::ParsedField(parsed_variable_declaration,visibility,default_value));
-}
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-void parser::Parser::skip_newlines() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 34: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightArithmeticShift>();
+utility::Span const& span = __jakt_match_value.value;
 {
-while (((((*this).current())).index() == 55 /* Eol */)){
-((((*this).index)++));
-}
-}
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_asterisk() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 35: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShiftEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::Dereference() } ,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
-}
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parser::Parser::parse_sum_enum_body(parser::ParsedRecord const partial_enum,parser::DefinitionLinkage const definition_linkage,bool const is_boxed) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 36: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Asterisk>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::DynamicArray<parser::ParsedMethod> methods = (TRY((DynamicArray<parser::ParsedMethod>::create_with({}))));
-JaktInternal::DynamicArray<parser::SumEnumVariant> variants = (TRY((DynamicArray<parser::SumEnumVariant>::create_with({}))));
-JaktInternal::DynamicArray<parser::ParsedField> fields = (TRY((DynamicArray<parser::ParsedField>::create_with({}))));
-bool seen_a_variant = false;
-if (((((*this).current())).index() == 9 /* LCurly */)){
-((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected `{` to start the enum body"sv),((((*this).current())).span())))));
-}
-
-((*this).skip_newlines());
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected variant or field name"sv),((((*this).previous())).span())))));
-return ((Tuple{variants, fields, methods}));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-JaktInternal::Optional<parser::Visibility> last_visibility = JaktInternal::OptionalNone();
-JaktInternal::Optional<utility::Span> last_visibility_span = JaktInternal::OptionalNone();
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 37: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Ampersand>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 5 /* Colon */)){
-parser::ParsedField const field = TRY((((*this).parse_field(last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; })))));
-if (seen_a_variant){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Common enum fields must be declared before variants"sv),span,Jakt::DeprecatedString("Previous variant is here"sv),(((((variants).last()).value())).span)))));
-}
-else {
-TRY((((fields).push(field))));
-}
-
-return JaktInternal::LoopContinue{};
-}
-(seen_a_variant = true);
-if ((!(((((*this).peek(static_cast<size_t>(1ULL)))).index() == 7 /* LParen */)))){
-((((*this).index)++));
-TRY((((variants).push(parser::SumEnumVariant(name,span,JaktInternal::OptionalNone())))));
-return JaktInternal::LoopContinue{};
-}
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
-JaktInternal::DynamicArray<parser::ParsedVarDecl> var_decls = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
-while ((!(((*this).eof())))){
-if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 5 /* Colon */)){
-parser::ParsedVarDecl var_decl = TRY((((*this).parse_variable_declaration(false))));
-if (((((var_decl).parsed_type))->index() == 0 /* Name */)){
-DeprecatedString const name = ((((var_decl).parsed_type))->get<parser::ParsedType::Name>()).name;
-utility::Span const span = ((((var_decl).parsed_type))->get<parser::ParsedType::Name>()).span;
-(((var_decl).inlay_span) = span);
-if (((name == ((partial_enum).name)) && (!(is_boxed)))){
-TRY((((*this).error(Jakt::DeprecatedString("use 'boxed enum' to make the enum recursive"sv),((var_decl).span)))));
-}
-}
-TRY((((var_decls).push(var_decl))));
-continue;
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 38: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((var_decls).push(parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((((*this).parse_typename()))),false,JaktInternal::OptionalNone(),((((*this).current())).span()))))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 11: {
+case 39: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandAmpersand>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((var_decls).push(parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((((*this).parse_typename()))),false,JaktInternal::OptionalNone(),((((*this).current())).span()))))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
+case 40: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Pipe>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((var_decls).push(parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((((*this).parse_typename()))),false,JaktInternal::OptionalNone(),((((*this).current())).span()))))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 41: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipeEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 8: {
+case 42: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipePipe>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 43: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Caret>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 44: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::CaretEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 45: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dollar>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Incomplete enum variant defintion, expected `,` or `)`; got ‘{}’"sv),((*this).current())))),((((*this).current())).span())))));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-TRY((((variants).push(parser::SumEnumVariant(name,span,var_decls)))));
+case 46: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 10: {
+case 47: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlash>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 48: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ExclamationPoint>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 49: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMark>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 89: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
+case 50: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMark>();
 utility::Span const& span = __jakt_match_value.value;
 {
-if (((last_visibility).has_value())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-(last_visibility =  parser::Visibility { typename parser::Visibility::Private() } );
-(last_visibility_span = span);
-((((*this).index)++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 51: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMarkEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 90: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
+case 52: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comma>();
 utility::Span const& span = __jakt_match_value.value;
 {
-if (((last_visibility).has_value())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-(last_visibility =  parser::Visibility { typename parser::Visibility::Public() } );
-(last_visibility_span = span);
-((((*this).index)++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 53: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 75: {
+case 54: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DotDot>();
+utility::Span const& span = __jakt_match_value.value;
 {
-bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
-parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = definition_linkage;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
-TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
-}
-parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; });
-(last_visibility = JaktInternal::OptionalNone());
-(last_visibility_span = JaktInternal::OptionalNone());
-parser::ParsedMethod const parsed_method = TRY((((*this).parse_method(function_linkage,visibility,false,false,is_comptime,false))));
-TRY((((methods).push(parsed_method))));
+case 55: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Eol>();utility::Span const& span = __jakt_match_value.span;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 76: {
+case 56: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Eof>();
+utility::Span const& span = __jakt_match_value.value;
 {
-bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
-parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
-auto&& __jakt_match_variant = definition_linkage;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
-TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
-}
-parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; });
-(last_visibility = JaktInternal::OptionalNone());
-(last_visibility_span = JaktInternal::OptionalNone());
-parser::ParsedMethod const parsed_method = TRY((((*this).parse_method(function_linkage,visibility,false,false,is_comptime,false))));
-TRY((((methods).push(parsed_method))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 57: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::FatArrow>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or the end of enum block"sv),((((*this).current())).span())))));
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-if ((!(((((*this).current())).index() == 10 /* RCurly */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Invalid enum definition, expected `}`"sv),((((*this).current())).span())))));
-return ((Tuple{variants, fields, methods}));
-}
-((((*this).index)++));
-if (((variants).is_empty())){
-TRY((((*this).error(Jakt::DeprecatedString("Empty enums are not allowed"sv),((partial_enum).name_span)))));
-}
-return ((Tuple{variants, fields, methods}));
-}
-}
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_shorthand_tuple() {
+case 58: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Arrow>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> types = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))));
-while ((!(((*this).eof())))){
-if (((((*this).current())).index() == 8 /* RParen */)){
-((((*this).index)++));
-return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::JaktTuple>(types,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
-}
-if (((((*this).current())).index() == 52 /* Comma */)){
-((((*this).index)++));
-}
-size_t const index_before = ((*this).index);
-NonnullRefPtr<typename parser::ParsedType> const type = TRY((((*this).parse_typename())));
-size_t const index_after = ((*this).index);
-if ((index_before == index_after)){
-break;
-}
-TRY((((types).push(type))));
-}
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘)’"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
-}
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-ErrorOr<parser::ParsedMatchPattern> parser::Parser::parse_match_pattern() {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ParsedMatchPattern, ErrorOr<parser::ParsedMatchPattern>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 100: {
-return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
-};/*case end*/
-case 73: {
-return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 70: {
-return JaktInternal::ExplicitValue(({ Optional<parser::ParsedMatchPattern> __jakt_var_31; {
-((((*this).index)++));
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments = TRY((((*this).parse_variant_arguments())));
-utility::Span const arguments_start = ((((*this).current())).span());
-utility::Span const arguments_end = ((((*this).previous())).span());
-utility::Span const arguments_span = TRY((parser::merge_spans(arguments_start,arguments_end)));
-__jakt_var_31 =  parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::CatchAll((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),variant_arguments,arguments_span) } ; goto __jakt_label_29;
-
+case 59: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::And>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-__jakt_label_29:; __jakt_var_31.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(({ Optional<parser::ParsedMatchPattern> __jakt_var_32; {
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> variant_names = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({}))));
-bool just_saw_name = false;
-while ((!(((*this).eof())))){
-((*this).skip_newlines());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedMatchPattern>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+case 60: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Anon>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (just_saw_name){
-return JaktInternal::LoopBreak{};
-}
-(just_saw_name = true);
-((((*this).index)++));
-TRY((((variant_names).push((Tuple{name, ((((*this).current())).span())})))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 6: {
+case 61: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::As>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-(just_saw_name = false);
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 62: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Boxed>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments = TRY((((*this).parse_variant_arguments())));
-utility::Span const arguments_start = ((((*this).current())).span());
-utility::Span const arguments_end = ((((*this).previous())).span());
-utility::Span const arguments_span = TRY((parser::merge_spans(arguments_start,arguments_end)));
-__jakt_var_32 =  parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::EnumVariant((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),variant_names,variant_arguments,arguments_span) } ; goto __jakt_label_30;
-
+case 63: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Break>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-__jakt_label_30:; __jakt_var_32.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<parser::ParsedMatchPattern> __jakt_var_33; {
-TRY((((*this).error(Jakt::DeprecatedString("Expected pattern or ‘else’"sv),((((*this).current())).span())))));
-__jakt_var_33 =  parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Invalid((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({}))))) } ; goto __jakt_label_31;
-
+case 64: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Catch>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-__jakt_label_31:; __jakt_var_33.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<void> parser::Parser::parse_import(parser::ParsedNamespace& parent) {
+case 65: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Class>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((((*this).current())).index() == 72 /* Extern */)){
-((((*this).index)++));
-TRY((((((parent))).add_extern_import(TRY((((*this).parse_extern_import(parent))))))));
-}
-else {
-TRY((((((parent))).add_module_import(TRY((((*this).parse_module_import())))))));
-}
-
-}
-return {};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-ErrorOr<JaktInternal::Optional<parser::NumericConstant>> parser::Parser::make_integer_numeric_constant(u64 const number,lexer::LiteralSuffix const suffix,utility::Span const span) {
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<parser::NumericConstant>>>{
-auto&& __jakt_match_variant = suffix;
-switch(__jakt_match_variant.index()) {
-case 0: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 66: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Continue>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<i64> const n = (fallible_integer_cast<i64>((number)));
-if (((n).has_value())){
-return ( parser::NumericConstant { typename parser::NumericConstant::UnknownSigned((n.value())) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::UnknownUnsigned(number) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
+case 67: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Cpp>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<u8> const n = (fallible_integer_cast<u8>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::U8((n.value())) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
+case 68: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Defer>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<u16> const n = (fallible_integer_cast<u16>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::U16((n.value())) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
+case 69: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Destructor>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<u32> const n = (fallible_integer_cast<u32>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::U32((n.value())) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 5: {
+case 70: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Else>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<u64> const n = (fallible_integer_cast<u64>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::U64((n.value())) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
+case 71: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Enum>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<size_t> const n = (fallible_integer_cast<size_t>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::USize((infallible_integer_cast<u64>(((n.value()))))) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 6: {
+case 72: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Extern>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<i8> const n = (fallible_integer_cast<i8>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::I8((n.value())) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 7: {
+case 73: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<i16> const n = (fallible_integer_cast<i16>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::I16((n.value())) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 8: {
+case 74: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::For>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<i32> const n = (fallible_integer_cast<i32>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::I32((n.value())) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
+case 75: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Fn>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Optional<i64> const n = (fallible_integer_cast<i64>((number)));
-if ((!(((n).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Number {} cannot fit in integer type {}"sv),number,suffix))),span))));
-return ( parser::NumericConstant { typename parser::NumericConstant::U64(number) } );
-}
-return ( parser::NumericConstant { typename parser::NumericConstant::I64((n.value())) } );
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 76: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comptime>();
+utility::Span const& span = __jakt_match_value.value;
 {
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-return (JaktInternal::OptionalNone());
-}
-}
-
-ErrorOr<parser::ParsedRecord> parser::Parser::parse_enum(parser::DefinitionLinkage const definition_linkage,bool const is_boxed) {
+case 77: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::If>();
+utility::Span const& span = __jakt_match_value.value;
 {
-parser::ParsedRecord parsed_enum = parser::ParsedRecord(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),definition_linkage,JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedMethod>::create_with({})))), parser::RecordType { typename parser::RecordType::Garbage() } ,JaktInternal::OptionalNone());
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> underlying_type = JaktInternal::OptionalNone();
-if (((((*this).current())).index() == 71 /* Enum */)){
-((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘enum’ keyword"sv),((((*this).current())).span())))));
-return (parsed_enum);
-}
-
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected name"sv),((((*this).current())).span())))));
-return (parsed_enum);
-}
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
-(((parsed_enum).name) = name);
-(((parsed_enum).name_span) = span);
-((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected name"sv),((((*this).current())).span())))));
-}
-
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected generic parameters or underlying type or body"sv),((((*this).current())).span())))));
-return (parsed_enum);
-}
-if (((((*this).current())).index() == 28 /* LessThan */)){
-(((parsed_enum).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
-}
-if (((((*this).current())).index() == 108 /* Implements */)){
-((((*this).index)++));
-(((parsed_enum).implements_list) = TRY((((*this).parse_trait_list()))));
-}
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected underlying type or body"sv),((((*this).current())).span())))));
-return (parsed_enum);
-}
-if (((((*this).current())).index() == 5 /* Colon */)){
-if (is_boxed){
-TRY((((*this).error(Jakt::DeprecatedString("Invalid enum definition: Value enums must not have an underlying type"sv),((((*this).current())).span())))));
-}
-((((*this).index)++));
-(underlying_type = TRY((((*this).parse_typename()))));
-}
-((*this).skip_newlines());
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected body"sv),((((*this).current())).span())))));
-return (parsed_enum);
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-if (((underlying_type).has_value())){
-JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>> const variants_methods_ = TRY((((*this).parse_value_enum_body(parsed_enum,definition_linkage))));
-JaktInternal::DynamicArray<parser::ValueEnumVariant> const variants = ((variants_methods_).template get<0>());
-JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((variants_methods_).template get<1>());
-
-(((parsed_enum).methods) = methods);
-(((parsed_enum).record_type) =  parser::RecordType { typename parser::RecordType::ValueEnum((underlying_type.value()),variants) } );
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 78: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Import>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-else {
-JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>> const variants_fields_methods_ = TRY((((*this).parse_sum_enum_body(parsed_enum,definition_linkage,is_boxed))));
-JaktInternal::DynamicArray<parser::SumEnumVariant> const variants = ((variants_fields_methods_).template get<0>());
-JaktInternal::DynamicArray<parser::ParsedField> const fields = ((variants_fields_methods_).template get<1>());
-JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((variants_fields_methods_).template get<2>());
-
-(((parsed_enum).methods) = methods);
-(((parsed_enum).record_type) =  parser::RecordType { typename parser::RecordType::SumEnum(is_boxed,fields,variants) } );
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 79: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::In>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-return (parsed_enum);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 80: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Is>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 81: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Let>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-ErrorOr<parser::Visibility> parser::Parser::parse_restricted_visibility_modifier() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 82: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Loop>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span restricted_span = ((((*this).current())).span());
-((((*this).index)++));
-if (((((*this).current())).index() == 7 /* LParen */)){
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘(’"sv),((((*this).current())).span())))));
-return ( parser::Visibility { typename parser::Visibility::Restricted((TRY((DynamicArray<parser::VisibilityRestriction>::create_with({})))),restricted_span) } );
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 83: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Match>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-JaktInternal::DynamicArray<parser::VisibilityRestriction> whitelist = (TRY((DynamicArray<parser::VisibilityRestriction>::create_with({}))));
-bool expect_comma = false;
-while ((((*this).index) < ((((*this).tokens)).size()))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::Visibility>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 8: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 84: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Mut>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comma>();
+case 85: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Namespace>();
 utility::Span const& span = __jakt_match_value.value;
 {
-if (expect_comma){
-(expect_comma = false);
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Unexpected comma"sv),span))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 86: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-((((*this).index)++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 87: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Or>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 88: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Override>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (expect_comma){
-TRY((((*this).error(Jakt::DeprecatedString("Expected comma"sv),((((*this).current())).span())))));
-}
-((*this).skip_newlines());
-JaktInternal::DynamicArray<DeprecatedString> names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-for (;;){
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-TRY((((names).push(name))));
-((((*this).index)++));
-if (((((*this).current())).index() == 6 /* ColonColon */)){
-((((*this).index)++));
-}
-else {
-break;
-}
-
-}
-else {
-break;
-}
-
-}
-if (((names).is_empty())){
-TRY((((*this).error(Jakt::DeprecatedString("Expected identifier"sv),((((*this).current())).span())))));
-}
-else {
-DeprecatedString const name = (((names).pop()).value());
-TRY((((whitelist).push(parser::VisibilityRestriction(names,name)))));
-}
-
-(expect_comma = true);
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-(((restricted_span).end) = ((((((*this).current())).span())).end));
-if (((whitelist).is_empty())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Restriction list cannot be empty"sv),restricted_span,Jakt::DeprecatedString("Did you mean to use ‘private’ instead of ‘restricted’?"sv),restricted_span))));
-}
-if (((((*this).current())).index() == 8 /* RParen */)){
-((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘)’"sv),((((*this).current())).span())))));
-}
-
-return ( parser::Visibility { typename parser::Visibility::Restricted(whitelist,restricted_span) } );
-}
-}
-
-ErrorOr<parser::ParsedRecord> parser::Parser::parse_record(parser::DefinitionLinkage const definition_linkage) {
+case 89: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ParsedRecord, ErrorOr<parser::ParsedRecord>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 96: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_struct(definition_linkage)))));
-};/*case end*/
-case 65: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_class(definition_linkage)))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 71: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_enum(definition_linkage,false)))));
+case 90: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 62: {
-return JaktInternal::ExplicitValue(({ Optional<parser::ParsedRecord> __jakt_var_34; {
-((((*this).index)++));
-__jakt_var_34 = TRY((((*this).parse_enum(definition_linkage,true)))); goto __jakt_label_32;
-
+case 91: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Raw>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-__jakt_label_32:; __jakt_var_34.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<parser::ParsedRecord> __jakt_var_35; {
-TRY((((*this).error(Jakt::DeprecatedString("Expected `struct`, `class`, `enum`, or `boxed`"sv),((((*this).current())).span())))));
-__jakt_var_35 = parser::ParsedRecord(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),definition_linkage,JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedMethod>::create_with({})))), parser::RecordType { typename parser::RecordType::Garbage() } ,JaktInternal::OptionalNone()); goto __jakt_label_33;
-
+case 92: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-__jakt_label_33:; __jakt_var_35.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 93: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Return>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 94: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedCapture>> parser::Parser::parse_captures() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 95: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::DynamicArray<parser::ParsedCapture> captures = (TRY((DynamicArray<parser::ParsedCapture>::create_with({}))));
-if (((((*this).current())).index() == 11 /* LSquare */)){
-((((*this).index)++));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::ParsedCapture>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 12: {
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 96: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Struct>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 37: {
+case 97: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::ParsedCapture>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 84: {
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 98: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throw>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByMutableReference(name,((((*this).current())).span())) } ))));
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected identifier, got '{}'"sv),((*this).current())))),((((*this).current())).span())))));
-((((*this).index)++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 99: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throws>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 100: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+case 101: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByReference(name,((((*this).current())).span())) } ))));
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 102: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Unsafe>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected identifier or mut, got '{}'"sv),((*this).current())))),((((*this).current())).span())))));
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
+case 103: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Virtual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 76: {
+case 104: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Weak>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByComptimeDependency(name,((((*this).current())).span())) } ))));
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected identifier, got '{}'"sv),((*this).current())))),((((*this).current())).span())))));
-((((*this).index)++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 105: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::While>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 106: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Yield>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+case 107: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Guard>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByValue(name,((((*this).current())).span())) } ))));
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 97: {
+case 108: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Implements>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByValue(Jakt::DeprecatedString("this"sv),((((*this).current())).span())) } ))));
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 109: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Requires>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 110: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Trait>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 111: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Garbage>();utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected token '{}' in captures list"sv),((*this).current())))),((((*this).current())).span())))));
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
 }
-return (captures);
-}
-else {
-return ((TRY((DynamicArray<parser::ParsedCapture>::create_with({})))));
-}
-
+return (alias);
 }
 }
 
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_try_block() {
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedParameter>> parser::Parser::parse_function_parameters() {
 {
-utility::Span const start_span = ((((*this).current())).span());
-NonnullRefPtr<typename parser::ParsedStatement> const stmt = TRY((((*this).parse_statement(false))));
-DeprecatedString error_name = Jakt::DeprecatedString(""sv);
-utility::Span error_span = ((((*this).current())).span());
-if (((((*this).current())).index() == 64 /* Catch */)){
-((((*this).index)++));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-(error_span = ((((*this).current())).span()));
-(error_name = name);
+if (((((*this).current())).index() == 7 /* LParen */)){
 ((((*this).index)++));
 }
-}
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘catch’"sv),((((*this).current())).span())))));
-}
-
-parser::ParsedBlock const catch_block = TRY((((*this).parse_block())));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::TryBlock>(stmt,error_name,error_span,catch_block,TRY((parser::merge_spans(start_span,((((*this).previous())).span()))))))));
-}
+TRY((((*this).error(Jakt::DeprecatedString("Expected '('"sv),((((*this).current())).span())))));
 }
 
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchPattern>> parser::Parser::parse_match_patterns() {
-{
-JaktInternal::DynamicArray<parser::ParsedMatchPattern> patterns = (TRY((DynamicArray<parser::ParsedMatchPattern>::create_with({}))));
 ((*this).skip_newlines());
+JaktInternal::DynamicArray<parser::ParsedParameter> params = (TRY((DynamicArray<parser::ParsedParameter>::create_with({}))));
+bool current_param_requires_label = true;
+bool current_param_is_mutable = false;
+bool error = false;
+bool parameter_complete = false;
 while ((!(((*this).eof())))){
-parser::ParsedMatchPattern pattern = TRY((((*this).parse_match_pattern())));
-ScopeGuard __jakt_var_36([&] {
-MUST((((patterns).push(pattern))));
-});
-JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults = ((pattern).defaults());
-((*this).skip_newlines());
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-if ((name == Jakt::DeprecatedString("default"sv))){
-JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults = ((pattern).defaults());
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
-if ((!(((((*this).current())).index() == 7 /* LParen */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected '(' after 'default'"sv),((((*this).current())).span())))));
-continue;
-}
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
-while (((!(((((*this).current())).index() == 8 /* RParen */))) && (!(((*this).eof()))))){
-bool const is_mutable = ((((*this).current())).index() == 84 /* Mut */);
-if (is_mutable){
-((((*this).index)++));
-}
-parser::ParsedVarDecl const declaration = TRY((((*this).parse_variable_declaration(is_mutable))));
-NonnullRefPtr<typename parser::ParsedExpression> const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchPattern>>>{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::ParsedParameter>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 16: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_37; {
+case 8: {
+{
 ((((*this).index)++));
-__jakt_var_37 = TRY((((*this).parse_expression(false,false)))); goto __jakt_label_34;
-
-}
-__jakt_label_34:; __jakt_var_37.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_38; {
-TRY((((*this).error(Jakt::DeprecatedString("Expected initializer"sv),((((*this).current())).span())))));
-__jakt_var_38 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))); goto __jakt_label_35;
-
+return JaktInternal::LoopBreak{};
 }
-__jakt_label_35:; __jakt_var_38.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-TRY((((defaults).set(((declaration).name),parser::ParsedPatternDefault(declaration,value)))));
-}
-if (((((*this).current())).index() == 8 /* RParen */)){
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected a ')' to end 'defaults' list"sv),((((*this).current())).span())))));
+case 52: {
+{
+if (((!(parameter_complete)) && (!(error)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected parameter"sv),((((*this).current())).span())))));
+(error = true);
 }
-
+((((*this).index)++));
+(current_param_requires_label = true);
+(current_param_is_mutable = false);
+(parameter_complete = false);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 55: {
+{
+if (((!(parameter_complete)) && (!(error)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected parameter"sv),((((*this).current())).span())))));
+(error = true);
 }
-((*this).skip_newlines());
-if (((((*this).current())).index() == 40 /* Pipe */)){
 ((((*this).index)++));
-continue;
+(current_param_requires_label = true);
+(current_param_is_mutable = false);
+(parameter_complete = false);
 }
-break;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 60: {
+{
+if ((parameter_complete && (!(error)))){
+TRY((((*this).error(Jakt::DeprecatedString("‘anon’ must appear at start of parameter declaration, not the end"sv),((((*this).current())).span())))));
+(error = true);
 }
-return (patterns);
+if ((current_param_is_mutable && (!(error)))){
+TRY((((*this).error(Jakt::DeprecatedString("‘anon’ must appear before ‘mut’"sv),((((*this).current())).span())))));
+(error = true);
 }
+if (((!(current_param_requires_label)) && (!(error)))){
+TRY((((*this).error(Jakt::DeprecatedString("‘anon’ cannot appear multiple times in one parameter declaration"sv),((((*this).current())).span())))));
+(error = true);
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_operand_postfix_operator(utility::Span const start,NonnullRefPtr<typename parser::ParsedExpression> const expr) {
-{
-NonnullRefPtr<typename parser::ParsedExpression> result = expr;
-for (;;){
-(result = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 54: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_39; {
 ((((*this).index)++));
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> to = JaktInternal::OptionalNone();
-utility::Span span_end = ((((*this).current())).span());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 12: {
-{
+(current_param_requires_label = false);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 84: {
 {
+if ((parameter_complete && (!(error)))){
+TRY((((*this).error(Jakt::DeprecatedString("‘mut’ must appear at start of parameter declaration, not the end"sv),((((*this).current())).span())))));
+(error = true);
+}
+if ((current_param_is_mutable && (!(error)))){
+TRY((((*this).error(Jakt::DeprecatedString("‘mut’ cannot appear multiple times in one parameter declaration"sv),((((*this).current())).span())))));
+(error = true);
+}
+((((*this).index)++));
+(current_param_is_mutable = true);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 97: {
 {
+TRY((((params).push(parser::ParsedParameter(false,parser::ParsedVariable(Jakt::DeprecatedString("this"sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),current_param_is_mutable,((((*this).current())).span())),JaktInternal::OptionalNone(),((((*this).current())).span()))))));
+((((*this).index)++));
+(parameter_complete = true);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 8: {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
+parser::ParsedVarDecl const var_decl = TRY((((*this).parse_variable_declaration(current_param_is_mutable))));
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_argument = JaktInternal::OptionalNone();
+if (((((*this).current())).index() == 16 /* Equal */)){
+((((*this).index)++));
+(default_argument = TRY((((*this).parse_expression(false,true)))));
+}
+TRY((((params).push(parser::ParsedParameter(current_param_requires_label,parser::ParsedVariable(((var_decl).name),((var_decl).parsed_type),((var_decl).is_mutable),((((*this).previous())).span())),default_argument,((((*this).previous())).span()))))));
+(parameter_complete = true);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-(to = TRY((((*this).parse_operand()))));
-(span_end = (((to.value()))->span()));
+if ((!(error))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected parameter"sv),((((*this).current())).span())))));
+(error = true);
+}
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-__jakt_var_39 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Range>(result,to,TRY((parser::merge_spans(start,span_end)))))); goto __jakt_label_36;
-
 }
-__jakt_label_36:; __jakt_var_39.release_value(); }));
-};/*case end*/
-case 48: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_40; {
-((((*this).index)++));
-__jakt_var_40 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::ForcedUnwrap>(result,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_37;
-
+return (params);
 }
-__jakt_label_37:; __jakt_var_40.release_value(); }));
-};/*case end*/
-case 18: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_41; {
-((((*this).index)++));
-__jakt_var_41 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::PostIncrement() } ,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_38;
-
 }
-__jakt_label_38:; __jakt_var_41.release_value(); }));
-};/*case end*/
-case 20: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_42; {
-((((*this).index)++));
-__jakt_var_42 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::PostDecrement() } ,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_39;
 
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchCase>> parser::Parser::parse_match_cases() {
+{
+JaktInternal::DynamicArray<parser::ParsedMatchCase> cases = (TRY((DynamicArray<parser::ParsedMatchCase>::create_with({}))));
+((*this).skip_newlines());
+if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
+return (cases);
 }
-__jakt_label_39:; __jakt_var_42.release_value(); }));
-};/*case end*/
-case 61: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_43; {
 ((((*this).index)++));
-utility::Span const cast_span = TRY((parser::merge_spans(((((*this).previous())).span()),((((*this).current())).span()))));
-parser::TypeCast const cast = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::TypeCast, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 48: {
-return JaktInternal::ExplicitValue(({ Optional<parser::TypeCast> __jakt_var_44; {
+((*this).skip_newlines());
+while (((!(((*this).eof()))) && (!(((((*this).current())).index() == 10 /* RCurly */))))){
+utility::Span const marker_span = ((((*this).current())).span());
+size_t const pattern_start_index = ((*this).index);
+JaktInternal::DynamicArray<parser::ParsedMatchPattern> const patterns = TRY((((*this).parse_match_patterns())));
+((*this).skip_newlines());
+if (((((*this).current())).index() == 57 /* FatArrow */)){
 ((((*this).index)++));
-__jakt_var_44 =  parser::TypeCast { typename parser::TypeCast::Infallible(TRY((((*this).parse_typename())))) } ; goto __jakt_label_41;
-
 }
-__jakt_label_41:; __jakt_var_44.release_value(); }));
-};/*case end*/
-case 49: {
-return JaktInternal::ExplicitValue(({ Optional<parser::TypeCast> __jakt_var_45; {
-((((*this).index)++));
-__jakt_var_45 =  parser::TypeCast { typename parser::TypeCast::Fallible(TRY((((*this).parse_typename())))) } ; goto __jakt_label_42;
-
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘=>’"sv),((((*this).current())).span())))));
 }
-__jakt_label_42:; __jakt_var_45.release_value(); }));
+
+((*this).skip_newlines());
+parser::ParsedMatchBody const body = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ParsedMatchBody, ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchCase>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 9: {
+return JaktInternal::ExplicitValue( parser::ParsedMatchBody { typename parser::ParsedMatchBody::Block(TRY((((*this).parse_block())))) } );
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<parser::TypeCast> __jakt_var_46; {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Invalid cast syntax"sv),cast_span,Jakt::DeprecatedString("Use `as!` for an infallible cast, or `as?` for a fallible cast"sv),((((*this).previous())).span())))));
-__jakt_var_46 =  parser::TypeCast { typename parser::TypeCast::Fallible(TRY((((*this).parse_typename())))) } ; goto __jakt_label_43;
-
-}
-__jakt_label_43:; __jakt_var_46.release_value(); }));
+return JaktInternal::ExplicitValue( parser::ParsedMatchBody { typename parser::ParsedMatchBody::Expression(TRY((((*this).parse_expression(false,true))))) } );
 };/*case end*/
 }/*switch end*/
 }()
 ));
-utility::Span const span = TRY((parser::merge_spans(start,TRY((parser::merge_spans(cast_span,((((*this).current())).span())))))));
-__jakt_var_43 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::TypeCast(cast) } ,span))); goto __jakt_label_40;
-
-}
-__jakt_label_40:; __jakt_var_43.release_value(); }));
-};/*case end*/
-case 80: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_47; {
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedType> const parsed_type = TRY((((*this).parse_typename())));
-utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> bindings = (TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({}))));
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> unary_operator_is = JaktInternal::OptionalNone();
-if ((((((*this).current())).index() == 7 /* LParen */) && (((parsed_type)->index() == 1 /* NamespacedName */) || ((parsed_type)->index() == 0 /* Name */)))){
-(bindings = TRY((((*this).parse_variant_arguments()))));
-(unary_operator_is = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::IsEnumVariant(parsed_type,bindings) } ,span))));
+{
+JaktInternal::ArrayIterator<parser::ParsedMatchPattern> _magic = ((patterns).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMatchPattern> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-(unary_operator_is = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::Is(parsed_type) } ,span))));
+parser::ParsedMatchPattern pattern = (_magic_value.value());
+{
+TRY((((cases).push(parser::ParsedMatchCase((TRY((DynamicArray<parser::ParsedMatchPattern>::create_with({pattern})))),marker_span,body)))));
 }
 
-__jakt_var_47 = (unary_operator_is.value()); goto __jakt_label_44;
+}
+}
 
+if ((((*this).index) == pattern_start_index)){
+break;
 }
-__jakt_label_44:; __jakt_var_47.release_value(); }));
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_postfix_colon_colon(start,result)))));
-};/*case end*/
-case 49: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_48; {
-bool const is_optional = ((((*this).current())).index() == 49 /* QuestionMark */);
-if (is_optional){
+if ((((((*this).current())).index() == 55 /* Eol */) || ((((*this).current())).index() == 52 /* Comma */))){
 ((((*this).index)++));
-if ((!(((((*this).current())).index() == 53 /* Dot */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘.’ after ‘?’ for optional chaining access"sv),((((*this).current())).span())))));
-}
 }
-((((*this).index)++));
-__jakt_var_48 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();lexer::LiteralPrefix const& prefix = __jakt_match_value.prefix;
-DeprecatedString const& number = __jakt_match_value.number;
-lexer::LiteralSuffix const& suffix = __jakt_match_value.suffix;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_49; {
-NonnullRefPtr<typename parser::ParsedExpression> const numeric_constant = TRY((((*this).parse_number(prefix,number,suffix,span))));
-__jakt_var_49 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto __jakt_enum_value = (((numeric_constant)->index() == 1 /* NumericConstant */));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_50; {
-parser::NumericConstant const val = ((numeric_constant)->get<parser::ParsedExpression::NumericConstant>()).val;
-size_t const num = ((val).to_usize());
-__jakt_var_50 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedTuple>(result,num,is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_47;
-
+((*this).skip_newlines());
 }
-__jakt_label_47:; __jakt_var_50.release_value(); }));
+((*this).skip_newlines());
+if ((!(((((*this).current())).index() == 10 /* RCurly */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘}’"sv),((((*this).current())).span())))));
 }
-else {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Invalid Numeric Constant"sv),span))));
-return (expr);
+((((*this).index)++));
+return (cases);
 }
 }
-}()))
-; goto __jakt_label_46;
 
-}
-__jakt_label_46:; __jakt_var_49.release_value(); }));
-};/*case end*/
+ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>> parser::Parser::parse_attribute() {
+{
+utility::Span const span = ((((*this).current())).span());
+DeprecatedString const name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_51; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_34; {
 ((((*this).index)++));
-__jakt_var_51 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 28: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_52; {
-size_t const original_index = ((*this).index);
-JaktInternal::DynamicArray<error::JaktError> const existing_errors = TRY((((((((((*this).compiler))->errors))[(JaktInternal::Range<i64>{static_cast<i64>(0LL),static_cast<i64>(9223372036854775807LL)})])).to_array())));
-((((*this).index)--));
-JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
-__jakt_var_52 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto __jakt_enum_value = (((call).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(result,(call.value()),is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
-}
-else {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_53; {
-(((*this).index) = original_index);
-(((((*this).compiler))->errors) = existing_errors);
-__jakt_var_53 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedStruct>(result,name,is_optional,TRY((parser::merge_spans(start,((((*this).current())).span()))))))); goto __jakt_label_50;
+__jakt_var_34 = name; goto __jakt_label_32;
 
 }
-__jakt_label_50:; __jakt_var_53.release_value(); }));
-}
-}()))
-; goto __jakt_label_49;
-
-}
-__jakt_label_49:; __jakt_var_52.release_value(); }));
+__jakt_label_32:; __jakt_var_34.release_value(); }));
 };/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_54; {
-((((*this).index)--));
-JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
-__jakt_var_54 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(result,(call.value()),is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_51;
+case 97: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_35; {
+((((*this).index)++));
+__jakt_var_35 = Jakt::DeprecatedString("this"sv); goto __jakt_label_33;
 
 }
-__jakt_label_51:; __jakt_var_54.release_value(); }));
+__jakt_label_33:; __jakt_var_35.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedStruct>(result,name,is_optional,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected identifier"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
+}
 };/*case end*/
 }/*switch end*/
 }()
-)); goto __jakt_label_48;
+));
+JaktInternal::DynamicArray<parser::ParsedAttributeArgument> arguments = (TRY((DynamicArray<parser::ParsedAttributeArgument>::create_with({}))));
+if (((((*this).current())).index() == 7 /* LParen */)){
+((((*this).index)++));
+while (((!(((*this).eof()))) && (!(((((*this).current())).index() == 8 /* RParen */))))){
+utility::Span const span = ((((*this).current())).span());
+DeprecatedString const argument_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_36; {
+((((*this).index)++));
+__jakt_var_36 = name; goto __jakt_label_34;
 
 }
-__jakt_label_48:; __jakt_var_51.release_value(); }));
+__jakt_label_34:; __jakt_var_36.release_value(); }));
 };/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_55; {
+case 97: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_37; {
 ((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const index = TRY((((*this).parse_expression(false,false))));
-if ((!(((((*this).current())).index() == 12 /* RSquare */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]’ to close the index"sv),((((*this).current())).span())))));
+__jakt_var_37 = Jakt::DeprecatedString("this"sv); goto __jakt_label_35;
+
 }
+__jakt_label_35:; __jakt_var_37.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_38; {
 ((((*this).index)++));
-__jakt_var_55 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::ComptimeIndex>(result,index,is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_52;
+__jakt_var_38 = quote; goto __jakt_label_36;
 
 }
-__jakt_label_52:; __jakt_var_55.release_value(); }));
+__jakt_label_36:; __jakt_var_38.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_56; {
-TRY((((*this).error(Jakt::DeprecatedString("Unsupported dot operation"sv),((((*this).current())).span())))));
-((((*this).index)++));
-__jakt_var_56 = result; goto __jakt_label_53;
-
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or string literal"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
 }
-__jakt_label_53:; __jakt_var_56.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
-)); goto __jakt_label_45;
-
-}
-__jakt_label_45:; __jakt_var_48.release_value(); }));
-};/*case end*/
-case 53: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_57; {
-bool const is_optional = ((((*this).current())).index() == 49 /* QuestionMark */);
-if (is_optional){
-((((*this).index)++));
-if ((!(((((*this).current())).index() == 53 /* Dot */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘.’ after ‘?’ for optional chaining access"sv),((((*this).current())).span())))));
-}
-}
+));
+JaktInternal::Optional<DeprecatedString> argument_value = JaktInternal::OptionalNone();
+if (((((*this).current())).index() == 5 /* Colon */)){
 ((((*this).index)++));
-__jakt_var_57 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+(argument_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<DeprecatedString>, ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();lexer::LiteralPrefix const& prefix = __jakt_match_value.prefix;
-DeprecatedString const& number = __jakt_match_value.number;
-lexer::LiteralSuffix const& suffix = __jakt_match_value.suffix;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_58; {
-NonnullRefPtr<typename parser::ParsedExpression> const numeric_constant = TRY((((*this).parse_number(prefix,number,suffix,span))));
-__jakt_var_58 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto __jakt_enum_value = (((numeric_constant)->index() == 1 /* NumericConstant */));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_59; {
-parser::NumericConstant const val = ((numeric_constant)->get<parser::ParsedExpression::NumericConstant>()).val;
-size_t const num = ((val).to_usize());
-__jakt_var_59 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedTuple>(result,num,is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_56;
-
-}
-__jakt_label_56:; __jakt_var_59.release_value(); }));
-}
-else {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Invalid Numeric Constant"sv),span))));
-return (expr);
-}
-}
-}()))
-; goto __jakt_label_55;
-
-}
-__jakt_label_55:; __jakt_var_58.release_value(); }));
-};/*case end*/
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_60; {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_39; {
 ((((*this).index)++));
-__jakt_var_60 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 28: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_61; {
-size_t const original_index = ((*this).index);
-JaktInternal::DynamicArray<error::JaktError> const existing_errors = TRY((((((((((*this).compiler))->errors))[(JaktInternal::Range<i64>{static_cast<i64>(0LL),static_cast<i64>(9223372036854775807LL)})])).to_array())));
-((((*this).index)--));
-JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
-__jakt_var_61 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto __jakt_enum_value = (((call).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(result,(call.value()),is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
-}
-else {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_62; {
-(((*this).index) = original_index);
-(((((*this).compiler))->errors) = existing_errors);
-__jakt_var_62 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedStruct>(result,name,is_optional,TRY((parser::merge_spans(start,((((*this).current())).span()))))))); goto __jakt_label_59;
+__jakt_var_39 = name; goto __jakt_label_37;
 
 }
-__jakt_label_59:; __jakt_var_62.release_value(); }));
-}
-}()))
-; goto __jakt_label_58;
+__jakt_label_37:; __jakt_var_39.release_value(); }));
+};/*case end*/
+case 97: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_40; {
+((((*this).index)++));
+__jakt_var_40 = Jakt::DeprecatedString("this"sv); goto __jakt_label_38;
 
 }
-__jakt_label_58:; __jakt_var_61.release_value(); }));
+__jakt_label_38:; __jakt_var_40.release_value(); }));
 };/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_63; {
-((((*this).index)--));
-JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
-__jakt_var_63 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(result,(call.value()),is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_60;
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_41; {
+((((*this).index)++));
+__jakt_var_41 = quote; goto __jakt_label_39;
 
 }
-__jakt_label_60:; __jakt_var_63.release_value(); }));
+__jakt_label_39:; __jakt_var_41.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedStruct>(result,name,is_optional,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or string literal"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
+}
 };/*case end*/
 }/*switch end*/
 }()
-)); goto __jakt_label_57;
-
+)));
 }
-__jakt_label_57:; __jakt_var_60.release_value(); }));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_64; {
+TRY((((arguments).push(parser::ParsedAttributeArgument(argument_name,span,argument_value)))));
+if (((((*this).current())).index() == 52 /* Comma */)){
 ((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const index = TRY((((*this).parse_expression(false,false))));
-if ((!(((((*this).current())).index() == 12 /* RSquare */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]’ to close the index"sv),((((*this).current())).span())))));
 }
+else if ((!(((((*this).current())).index() == 8 /* RParen */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘,’ or ‘)’"sv),((((*this).current())).span())))));
+break;
+}
+}
+if (((((*this).current())).index() == 8 /* RParen */)){
 ((((*this).index)++));
-__jakt_var_64 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::ComptimeIndex>(result,index,is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_61;
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘)’"sv),((((*this).current())).span())))));
+}
 
 }
-__jakt_label_61:; __jakt_var_64.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_65; {
-TRY((((*this).error(Jakt::DeprecatedString("Unsupported dot operation"sv),((((*this).current())).span())))));
+JaktInternal::Optional<DeprecatedString> assigned_value = JaktInternal::OptionalNone();
+if (((((*this).current())).index() == 16 /* Equal */)){
+((((*this).index)++));
+(assigned_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<DeprecatedString>, ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_42; {
 ((((*this).index)++));
-__jakt_var_65 = result; goto __jakt_label_62;
+__jakt_var_42 = static_cast<JaktInternal::Optional<DeprecatedString>>(name); goto __jakt_label_40;
 
 }
-__jakt_label_62:; __jakt_var_65.release_value(); }));
+__jakt_label_40:; __jakt_var_42.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_54;
+case 97: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_43; {
+((((*this).index)++));
+__jakt_var_43 = Jakt::DeprecatedString("this"sv); goto __jakt_label_41;
 
 }
-__jakt_label_54:; __jakt_var_57.release_value(); }));
+__jakt_label_41:; __jakt_var_43.release_value(); }));
 };/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_66; {
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const index_expr = TRY((((*this).parse_expression(false,false))));
-if (((((*this).current())).index() == 12 /* RSquare */)){
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_44; {
 ((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ']'"sv),((((*this).current())).span())))));
-}
-
-size_t const end = (JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL)));
-__jakt_var_66 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedExpression>(result,index_expr,TRY((parser::merge_spans(start,((((((*this).tokens))[end])).span()))))))); goto __jakt_label_63;
+__jakt_var_44 = static_cast<JaktInternal::Optional<DeprecatedString>>(quote); goto __jakt_label_42;
 
 }
-__jakt_label_63:; __jakt_var_66.release_value(); }));
+__jakt_label_42:; __jakt_var_44.release_value(); }));
 };/*case end*/
 default: {
-{
-return JaktInternal::LoopBreak{};
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_45; {
+TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or string literal"sv),((((*this).current())).span())))));
+__jakt_var_45 = JaktInternal::OptionalNone(); goto __jakt_label_43;
+
 }
+__jakt_label_43:; __jakt_var_45; }));
 };/*case end*/
 }/*switch end*/
 }()
 )));
 }
-return (result);
+return (parser::ParsedAttribute(name,span,assigned_value,arguments));
 }
 }
 
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedGenericParameter>> parser::Parser::parse_generic_parameters() {
+ErrorOr<parser::ParsedMethod> parser::Parser::parse_method(parser::FunctionLinkage const linkage,parser::Visibility const visibility,bool const is_virtual,bool const is_override,bool const is_comptime,bool const is_destructor) {
 {
-if ((!(((((*this).current())).index() == 28 /* LessThan */)))){
-return ((TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))));
+parser::ParsedFunction parsed_function = TRY((((*this).parse_function(linkage,visibility,is_comptime,is_destructor,false))));
+if (((linkage).index() == 1 /* External */)){
+(((parsed_function).must_instantiate) = true);
 }
-((((*this).index)++));
-JaktInternal::DynamicArray<parser::ParsedGenericParameter> generic_parameters = (TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({}))));
-((*this).skip_newlines());
-bool saw_ending_bracket = false;
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::ParsedGenericParameter>>>{
+return (parser::ParsedMethod(parsed_function,visibility,is_virtual,is_override));
+}
+}
+
+ErrorOr<parser::ParsedNamespace> parser::Parser::parse_namespace() {
+{
+parser::ParsedNamespace parsed_namespace = parser::ParsedNamespace(JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedFunction>::create_with({})))),(TRY((DynamicArray<parser::ParsedRecord>::create_with({})))),(TRY((DynamicArray<parser::ParsedTrait>::create_with({})))),(TRY((DynamicArray<parser::ParsedExternalTraitImplementation>::create_with({})))),(TRY((DynamicArray<parser::ParsedNamespace>::create_with({})))),(TRY((DynamicArray<parser::ParsedAlias>::create_with({})))),(TRY((DynamicArray<parser::ParsedModuleImport>::create_with({})))),(TRY((DynamicArray<parser::ParsedExternImport>::create_with({})))),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))));
+JaktInternal::DynamicArray<parser::ParsedAttribute> active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({}))));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedNamespace>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
+case 110: {
+{
+if ((!(((active_attributes).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to trait declarations"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+}
+((((*this).index)++));
+TRY((((((parsed_namespace).traits)).push(TRY((((*this).parse_trait())))))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
 case 3: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<parser::ParsedNamespace>>{
+auto __jakt_enum_value = (name);
+if (__jakt_enum_value == Jakt::DeprecatedString("type"sv)) {
 {
-JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> requires_list = JaktInternal::OptionalNone();
-((((*this).index)++));
-if (((((*this).current())).index() == 109 /* Requires */)){
+if ((!(((active_attributes).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to external trait declarations"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+}
 ((((*this).index)++));
-(requires_list = TRY((((*this).parse_trait_list()))));
+TRY((((((parsed_namespace).external_trait_implementations)).push(TRY((((*this).parse_external_trait_implementation())))))));
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("use"sv)) {
+{
+if ((!(((active_attributes).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to use declarations"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
 }
-TRY((((generic_parameters).push(parser::ParsedGenericParameter(name,span,requires_list)))));
-if ((((((*this).current())).index() == 52 /* Comma */) || ((((*this).current())).index() == 55 /* Eol */))){
 ((((*this).index)++));
+TRY((((((parsed_namespace).aliases)).push(TRY((((*this).parse_using())))))));
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else {
+{
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((*this).error(Jakt::DeprecatedString("Unexpected token (expected keyword)"sv),((((*this).current())).span())))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
 }
 return JaktInternal::ExplicitValue<void>();
+}()))
+), JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 26: {
+case 78: {
 {
+if ((!(((active_attributes).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to imports"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+}
 ((((*this).index)++));
-(saw_ending_bracket = true);
-return JaktInternal::LoopBreak{};
+TRY((((*this).parse_import(((parsed_namespace))))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 33: {
+case 11: {
 {
-TRY((((*this).inject_token( lexer::Token { typename lexer::Token::GreaterThan(((((*this).current())).span())) } ))));
+if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 11 /* LSquare */)){
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
+TRY((((*this).parse_attribute_list(((active_attributes))))));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Unexpected token (expected ‘[[’)"sv),((((*this).current())).span())))));
 ({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
-(saw_ending_bracket = true);
-return JaktInternal::LoopBreak{};
+}
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 111: {
+case 75: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected `>` to end the generic parameters"sv),((((*this).current())).span())))));
-return (generic_parameters);
+parser::ParsedFunction parsed_function = TRY((((*this).parse_function( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } , parser::Visibility { typename parser::Visibility::Public() } ,((((*this).current())).index() == 76 /* Comptime */),false,false))));
+TRY((((*this).apply_attributes(((parsed_function)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).functions)).push(parsed_function))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 76: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected generic parameter name"sv),((((*this).current())).span())))));
-return (generic_parameters);
+parser::ParsedFunction parsed_function = TRY((((*this).parse_function( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } , parser::Visibility { typename parser::Visibility::Public() } ,((((*this).current())).index() == 76 /* Comptime */),false,false))));
+TRY((((*this).apply_attributes(((parsed_function)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).functions)).push(parsed_function))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-if ((!(saw_ending_bracket))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected `>` to end the generic parameters"sv),((((*this).current())).span())))));
-return (generic_parameters);
-}
-return (generic_parameters);
-}
-}
-
-ErrorOr<parser::ParsedMethod> parser::Parser::parse_method(parser::FunctionLinkage const linkage,parser::Visibility const visibility,bool const is_virtual,bool const is_override,bool const is_comptime,bool const is_destructor) {
+case 96: {
 {
-parser::ParsedFunction parsed_function = TRY((((*this).parse_function(linkage,visibility,is_comptime,is_destructor,false))));
-if (((linkage).index() == 1 /* External */)){
-(((parsed_function).must_instantiate) = true);
+parser::ParsedRecord parsed_record = TRY((((*this).parse_record( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ))));
+TRY((((*this).apply_attributes(((parsed_record)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).records)).push(parsed_record))));
 }
-return (parser::ParsedMethod(parsed_function,visibility,is_virtual,is_override));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 65: {
+{
+parser::ParsedRecord parsed_record = TRY((((*this).parse_record( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ))));
+TRY((((*this).apply_attributes(((parsed_record)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).records)).push(parsed_record))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 71: {
+{
+parser::ParsedRecord parsed_record = TRY((((*this).parse_record( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ))));
+TRY((((*this).apply_attributes(((parsed_record)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).records)).push(parsed_record))));
 }
-
-ErrorOr<parser::ParsedExternalTraitImplementation> parser::Parser::parse_external_trait_implementation() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 62: {
 {
-NonnullRefPtr<typename parser::ParsedType> const type_name = TRY((((*this).parse_typename())));
-((*this).skip_newlines());
-if (((((*this).current())).index() == 108 /* Implements */)){
-((((*this).index)++));
+parser::ParsedRecord parsed_record = TRY((((*this).parse_record( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ))));
+TRY((((*this).apply_attributes(((parsed_record)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).records)).push(parsed_record))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘implements’"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 85: {
+{
+if ((!(((active_attributes).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to namespaces"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
 }
+((((*this).index)++));
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>> const name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>>, ErrorOr<parser::ParsedNamespace>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_46; {
+((((*this).index)++));
+__jakt_var_46 = static_cast<JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>>>((Tuple{name, span})); goto __jakt_label_44;
 
-JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> const trait_list = TRY((((*this).parse_trait_list())));
-if ((!(((trait_list).has_value())))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected non-empty trait list"sv),((((*this).current())).span())))));
-return (parser::ParsedExternalTraitImplementation(type_name,(TRY((DynamicArray<parser::ParsedNameWithGenericParameters>::create_with({})))),(TRY((DynamicArray<parser::ParsedMethod>::create_with({}))))));
 }
+__jakt_label_44:; __jakt_var_46.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+}/*switch end*/
+}()
+));
 ((*this).skip_newlines());
 if (((((*this).current())).index() == 9 /* LCurly */)){
-JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>> const fields_methods_ = TRY((((*this).parse_struct_class_body( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } , parser::Visibility { typename parser::Visibility::Public() } ,false))));
-JaktInternal::DynamicArray<parser::ParsedField> const fields = ((fields_methods_).template get<0>());
-JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((fields_methods_).template get<1>());
-
-if ((!(((fields).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("External trait implementations cannot have fields"sv),((((((fields)[static_cast<i64>(0LL)])).var_decl)).span)))));
-}
-return (parser::ParsedExternalTraitImplementation(type_name,(trait_list.value()),methods));
+((((*this).index)++));
 }
 else {
 TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
-return (parser::ParsedExternalTraitImplementation(type_name,(trait_list.value()),(TRY((DynamicArray<parser::ParsedMethod>::create_with({}))))));
 }
 
+parser::ParsedNamespace namespace_ = TRY((((*this).parse_namespace())));
+if (((((*this).current())).index() == 10 /* RCurly */)){
+((((*this).index)++));
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete namespace"sv),((((*this).previous())).span())))));
 }
 
-ErrorOr<DeprecatedString> parser::Parser::parse_argument_label() {
-{
-if ((((((*this).peek(static_cast<size_t>(1ULL)))).index() == 5 /* Colon */) && ((((*this).current())).index() == 3 /* Identifier */))){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
-return (name);
-}
-return (Jakt::DeprecatedString(""sv));
+if (((name).has_value())){
+(((namespace_).name) = (((name.value())).template get<0>()));
+(((namespace_).name_span) = (((name.value())).template get<1>()));
 }
+TRY((((parsed_namespace).add_child_namespace(namespace_))));
 }
-
-ErrorOr<parser::ParsedTrait> parser::Parser::parse_trait() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 72: {
 {
-parser::ParsedTrait parsed_trait = parser::ParsedTrait(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),(TRY((DynamicArray<parser::ParsedFunction>::create_with({})))));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const name_span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
-(((parsed_trait).name) = name);
-(((parsed_trait).name_span) = name_span);
-((((*this).index)++));
-if (((((*this).current())).index() == 28 /* LessThan */)){
-(((parsed_trait).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
-}
-if (((((*this).current())).index() == 9 /* LCurly */)){
 ((((*this).index)++));
-for (;;){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedTrait>>{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedNamespace>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 10: {
+case 75: {
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+parser::ParsedFunction parsed_function = TRY((((*this).parse_function( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } , parser::Visibility { typename parser::Visibility::Public() } ,false,false,false))));
+TRY((((*this).apply_attributes(((parsed_function)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).functions)).push(parsed_function))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 56: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Eof>();
-utility::Span const& span = __jakt_match_value.value;
+case 96: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '}' to close the trait body"sv),span))));
+parser::ParsedRecord parsed_struct = TRY((((*this).parse_struct( parser::DefinitionLinkage { typename parser::DefinitionLinkage::External() } ))));
+TRY((((*this).apply_attributes(((parsed_struct)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).records)).push(parsed_struct))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 65: {
 {
-((((*this).index)++));
-return JaktInternal::LoopContinue{};
+parser::ParsedRecord parsed_class = TRY((((*this).parse_class( parser::DefinitionLinkage { typename parser::DefinitionLinkage::External() } ))));
+TRY((((*this).apply_attributes(((parsed_class)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((((parsed_namespace).records)).push(parsed_class))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 75: {
+default: {
 {
-parser::ParsedFunction method = TRY((((*this).parse_function( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } , parser::Visibility { typename parser::Visibility::Public() } ,false,false,true))));
-if (((((((method).block)).stmts)).is_empty())){
-(((method).linkage) =  parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
-}
-TRY((((((parsed_trait).methods)).push(method))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((*this).error(Jakt::DeprecatedString("Unexpected keyword"sv),((((*this).current())).span())))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+}/*switch end*/
+}()
+));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();utility::Span const& span = __jakt_match_value.span;
+case 55: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();utility::Span const& span = __jakt_match_value.span;
+case 10: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();utility::Span const& span = __jakt_match_value.span;
+default: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+TRY((((*this).error(Jakt::DeprecatedString("Unexpected token (expected keyword)"sv),((((*this).current())).span())))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Semicolon>();
-utility::Span const& span = __jakt_match_value.value;
+}/*switch end*/
+}()
+));
+}
+return (parsed_namespace);
+}
+}
+
+ErrorOr<parser::ParsedVarDecl> parser::Parser::parse_variable_declaration(bool const is_mutable) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+utility::Span const span = ((((*this).current())).span());
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+((((*this).index)++));
+if (((((*this).current())).index() == 5 /* Colon */)){
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Colon>();
-utility::Span const& span = __jakt_match_value.value;
+else {
+return (parser::ParsedVarDecl(name,TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),is_mutable,span,span));
+}
+
+NonnullRefPtr<typename parser::ParsedType> const parsed_type = TRY((((*this).parse_typename())));
+if ((is_mutable && (((parsed_type)->index() == 8 /* Reference */) || ((parsed_type)->index() == 9 /* MutableReference */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Reference parameter can not be mutable"sv),span))));
+}
+return (parser::ParsedVarDecl(name,parsed_type,is_mutable,JaktInternal::OptionalNone(),span));
+}
+else {
+return (parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),false,JaktInternal::OptionalNone(),span));
+}
+
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_shorthand_set() {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+utility::Span const start = ((((*this).current())).span());
+if (((((*this).current())).index() == 9 /* LCurly */)){
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ColonColon>();
-utility::Span const& span = __jakt_match_value.value;
+NonnullRefPtr<typename parser::ParsedType> const inner = TRY((((*this).parse_typename())));
+if (((((*this).current())).index() == 10 /* RCurly */)){
+((((*this).index)++));
+return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Set>(inner,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
+}
+TRY((((*this).error(Jakt::DeprecatedString("Expected '}'"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parser::Parser::parse_if_statement() {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if ((!(((((*this).current())).index() == 77 /* If */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘if’ statement"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Garbage>(((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
-utility::Span const& span = __jakt_match_value.value;
+utility::Span const start_span = ((((*this).current())).span());
+((((*this).index)++));
+bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
+(((*this).can_have_trailing_closure) = false);
+NonnullRefPtr<typename parser::ParsedExpression> const condition = TRY((((*this).parse_expression(false,true))));
+(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
+parser::ParsedBlock const then_block = TRY((((*this).parse_block())));
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> else_statement = JaktInternal::OptionalNone();
+((*this).skip_newlines());
+if (((((*this).current())).index() == 70 /* Else */)){
+((((*this).index)++));
+((*this).skip_newlines());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 77: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+(else_statement = TRY((((*this).parse_if_statement()))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RParen>();
-utility::Span const& span = __jakt_match_value.value;
+case 9: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+parser::ParsedBlock const block = TRY((((*this).parse_block())));
+if (((then_block).equals(block))){
+TRY((((*this).error(Jakt::DeprecatedString("if and else have identical blocks"sv),((((*this).current())).span())))));
+}
+(else_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(block,TRY((parser::merge_spans(start_span,((((*this).previous())).span()))))))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LCurly>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+TRY((((*this).error(Jakt::DeprecatedString("‘else’ missing ‘if’ or block"sv),((((*this).previous())).span())))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LSquare>();
-utility::Span const& span = __jakt_match_value.value;
+}/*switch end*/
+}()
+));
+}
+return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::If>(condition,then_block,else_statement,TRY((parser::merge_spans(start_span,((((*this).previous())).span()))))))));
+}
+}
+
+ErrorOr<JaktInternal::Optional<parser::ParsedCall>> parser::Parser::parse_call() {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+parser::ParsedCall call = parser::ParsedCall((TRY((DynamicArray<DeprecatedString>::create_with({})))),Jakt::DeprecatedString(""sv),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({})))));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+(((call).name) = name);
+((((*this).index)++));
+size_t const index_reset = ((*this).index);
+if (((((*this).current())).index() == 28 /* LessThan */)){
+((((*this).index)++));
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> inner_types = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<parser::ParsedCall>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 26: {
+{
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RSquare>();
-utility::Span const& span = __jakt_match_value.value;
+case 33: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+TRY((((*this).inject_token( lexer::Token { typename lexer::Token::GreaterThan(((((*this).current())).span())) } ))));
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSign>();
-utility::Span const& span = __jakt_match_value.value;
+case 52: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Plus>();
-utility::Span const& span = __jakt_match_value.value;
+case 55: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+size_t const index_before = ((*this).index);
+NonnullRefPtr<typename parser::ParsedType> const inner_type = TRY((((*this).parse_typename())));
+if ((index_before == ((*this).index))){
+(((*this).index) = index_reset);
+return JaktInternal::LoopBreak{};
+}
+TRY((((inner_types).push(inner_type))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Equal>();
-utility::Span const& span = __jakt_match_value.value;
+}/*switch end*/
+}()
+));
+}
+(((call).type_args) = inner_types);
+}
+if (((((*this).current())).index() == 7 /* LParen */)){
+((((*this).index)++));
+}
+else {
+(((*this).index) = index_reset);
+TRY((((*this).error(Jakt::DeprecatedString("Expected '('"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
+}
+
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<parser::ParsedCall>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 8: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusEqual>();
-utility::Span const& span = __jakt_match_value.value;
+case 55: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
-utility::Span const& span = __jakt_match_value.value;
+case 52: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusEqual>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+utility::Span const label_span = ((((*this).current())).span());
+DeprecatedString const label = TRY((((*this).parse_argument_label())));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+TRY((((((call).args)).push((Tuple{label, label_span, expr})))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+}/*switch end*/
+}()
+));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AsteriskEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if ((((*this).can_have_trailing_closure) && ((((*this).current())).index() == 9 /* LCurly */))){
+utility::Span const start = ((((*this).current())).span());
+parser::ParsedBlock const block = TRY((((*this).parse_block())));
+utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
+JaktInternal::DynamicArray<parser::ParsedCapture> const captures = (TRY((DynamicArray<parser::ParsedCapture>::create_with({ parser::ParsedCapture { typename parser::ParsedCapture::AllByReference(Jakt::DeprecatedString(""sv),((*this).empty_span())) } }))));
+NonnullRefPtr<typename parser::ParsedExpression> const trailing_closure = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Function>(captures,(TRY((DynamicArray<parser::ParsedParameter>::create_with({})))),false,false,TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),block,span)));
+NonnullRefPtr<typename parser::ParsedExpression> const reference_to_closure = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(trailing_closure, parser::UnaryOperator { typename parser::UnaryOperator::Reference() } ,span)));
+TRY((((((call).args)).push((Tuple{Jakt::DeprecatedString(""sv), ((*this).empty_span()), reference_to_closure})))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlashEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+return (call);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSignEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected function call"sv),((((*this).current())).span())))));
+return (call);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::NotEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DoubleEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThan>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<void> parser::Parser::inject_token(lexer::Token const token) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+TRY((((((*this).tokens)).insert((JaktInternal::checked_add<size_t>(((*this).index),static_cast<size_t>(1ULL))),token))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThanOrEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+return {};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThan>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<parser::ParsedRecord> parser::Parser::parse_class(parser::DefinitionLinkage const definition_linkage) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+parser::ParsedRecord parsed_class = parser::ParsedRecord(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),definition_linkage,JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedMethod>::create_with({})))), parser::RecordType { typename parser::RecordType::Garbage() } ,JaktInternal::OptionalNone());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> super_type = JaktInternal::OptionalNone();
+if (((((*this).current())).index() == 65 /* Class */)){
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThanOrEqual>();
-utility::Span const& span = __jakt_match_value.value;
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected `class` keyword"sv),((((*this).current())).span())))));
+return (parsed_class);
+}
+
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected name"sv),((((*this).current())).span())))));
+return (parsed_class);
+}
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
+((((*this).index)++));
+(((parsed_class).name) = name);
+(((parsed_class).name_span) = span);
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected name"sv),((((*this).current())).span())))));
+}
+
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected generic parameters or super class or body"sv),((((*this).current())).span())))));
+return (parsed_class);
+}
+(((parsed_class).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
+if (((((*this).current())).index() == 108 /* Implements */)){
+((((*this).index)++));
+(((parsed_class).implements_list) = TRY((((*this).parse_trait_list()))));
+}
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected super class or body"sv),((((*this).current())).span())))));
+return (parsed_class);
+}
+if (((((*this).current())).index() == 5 /* Colon */)){
+((((*this).index)++));
+(super_type = TRY((((*this).parse_typename()))));
+}
+((*this).skip_newlines());
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete class definition, expected body"sv),((((*this).current())).span())))));
+return (parsed_class);
+}
+JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>> const fields_methods_ = TRY((((*this).parse_struct_class_body(definition_linkage, parser::Visibility { typename parser::Visibility::Private() } ,true))));
+JaktInternal::DynamicArray<parser::ParsedField> const fields = ((fields_methods_).template get<0>());
+JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((fields_methods_).template get<1>());
+
+(((parsed_class).methods) = methods);
+(((parsed_class).record_type) =  parser::RecordType { typename parser::RecordType::Class(fields,super_type) } );
+return (parsed_class);
+}
+}
+
+ErrorOr<parser::ParsedExternalTraitImplementation> parser::Parser::parse_external_trait_implementation() {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+NonnullRefPtr<typename parser::ParsedType> const type_name = TRY((((*this).parse_typename())));
+((*this).skip_newlines());
+if (((((*this).current())).index() == 108 /* Implements */)){
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 30: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftArithmeticShift>();
-utility::Span const& span = __jakt_match_value.value;
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘implements’"sv),((((*this).current())).span())))));
+}
+
+JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> const trait_list = TRY((((*this).parse_trait_list())));
+if ((!(((trait_list).has_value())))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected non-empty trait list"sv),((((*this).current())).span())))));
+return (parser::ParsedExternalTraitImplementation(type_name,(TRY((DynamicArray<parser::ParsedNameWithGenericParameters>::create_with({})))),(TRY((DynamicArray<parser::ParsedMethod>::create_with({}))))));
+}
+((*this).skip_newlines());
+if (((((*this).current())).index() == 9 /* LCurly */)){
+JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>> const fields_methods_ = TRY((((*this).parse_struct_class_body( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } , parser::Visibility { typename parser::Visibility::Public() } ,false))));
+JaktInternal::DynamicArray<parser::ParsedField> const fields = ((fields_methods_).template get<0>());
+JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((fields_methods_).template get<1>());
+
+if ((!(((fields).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("External trait implementations cannot have fields"sv),((((((fields)[static_cast<i64>(0LL)])).var_decl)).span)))));
+}
+return (parser::ParsedExternalTraitImplementation(type_name,(trait_list.value()),methods));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
+return (parser::ParsedExternalTraitImplementation(type_name,(trait_list.value()),(TRY((DynamicArray<parser::ParsedMethod>::create_with({}))))));
+}
+
+}
+}
+
+ErrorOr<parser::ParsedMatchPattern> parser::Parser::parse_match_pattern() {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ParsedMatchPattern, ErrorOr<parser::ParsedMatchPattern>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 100: {
+return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
+};/*case end*/
+case 73: {
+return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue( parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Expression((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),TRY((((*this).parse_operand())))) } );
+};/*case end*/
+case 70: {
+return JaktInternal::ExplicitValue(({ Optional<parser::ParsedMatchPattern> __jakt_var_47; {
+((((*this).index)++));
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments = TRY((((*this).parse_variant_arguments())));
+utility::Span const arguments_start = ((((*this).current())).span());
+utility::Span const arguments_end = ((((*this).previous())).span());
+utility::Span const arguments_span = TRY((parser::merge_spans(arguments_start,arguments_end)));
+__jakt_var_47 =  parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::CatchAll((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),variant_arguments,arguments_span) } ; goto __jakt_label_45;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_45:; __jakt_var_47.release_value(); }));
 };/*case end*/
-case 31: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShift>();
-utility::Span const& span = __jakt_match_value.value;
+case 3: {
+return JaktInternal::ExplicitValue(({ Optional<parser::ParsedMatchPattern> __jakt_var_48; {
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> variant_names = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({}))));
+bool just_saw_name = false;
+while ((!(((*this).eof())))){
+((*this).skip_newlines());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedMatchPattern>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (just_saw_name){
+return JaktInternal::LoopBreak{};
+}
+(just_saw_name = true);
+((((*this).index)++));
+TRY((((variant_names).push((Tuple{name, ((((*this).current())).span())})))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 32: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShiftEqual>();
-utility::Span const& span = __jakt_match_value.value;
+case 6: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
+(just_saw_name = false);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 33: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShift>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 34: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightArithmeticShift>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+}/*switch end*/
+}()
+));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 35: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShiftEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments = TRY((((*this).parse_variant_arguments())));
+utility::Span const arguments_start = ((((*this).current())).span());
+utility::Span const arguments_end = ((((*this).previous())).span());
+utility::Span const arguments_span = TRY((parser::merge_spans(arguments_start,arguments_end)));
+__jakt_var_48 =  parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::EnumVariant((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({})))),variant_names,variant_arguments,arguments_span) } ; goto __jakt_label_46;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_46:; __jakt_var_48.release_value(); }));
 };/*case end*/
-case 36: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Asterisk>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+default: {
+return JaktInternal::ExplicitValue(({ Optional<parser::ParsedMatchPattern> __jakt_var_49; {
+TRY((((*this).error(Jakt::DeprecatedString("Expected pattern or ‘else’"sv),((((*this).current())).span())))));
+__jakt_var_49 =  parser::ParsedMatchPattern { typename parser::ParsedMatchPattern::Invalid((TRY((Dictionary<DeprecatedString, parser::ParsedPatternDefault>::create_with_entries({}))))) } ; goto __jakt_label_47;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_47:; __jakt_var_49.release_value(); }));
 };/*case end*/
-case 37: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Ampersand>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+}/*switch end*/
+}()
+)));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 38: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 39: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandAmpersand>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<parser::ParsedFunction> parser::Parser::parse_function(parser::FunctionLinkage const linkage,parser::Visibility const visibility,bool const is_comptime,bool const is_destructor,bool const allow_missing_body) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+parser::ParsedFunction parsed_function = parser::ParsedFunction(Jakt::DeprecatedString(""sv),((*this).empty_span()),visibility,(TRY((DynamicArray<parser::ParsedParameter>::create_with({})))),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({}))))),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),((*this).span(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL))),false, parser::FunctionType { typename parser::FunctionType::Normal() } ,linkage,false,is_comptime,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone());
+if (is_destructor){
+(((parsed_function).type) =  parser::FunctionType { typename parser::FunctionType::Destructor() } );
+TRY((((((parsed_function).params)).push(parser::ParsedParameter(false,parser::ParsedVariable(Jakt::DeprecatedString("this"sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),true,((((*this).current())).span())),JaktInternal::OptionalNone(),((((*this).current())).span()))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 40: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Pipe>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if ((!(is_destructor))){
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 41: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipeEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete function definition"sv),((((*this).current())).span())))));
+return (parsed_function);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 42: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipePipe>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (is_destructor){
+(((parsed_function).name) = Jakt::DeprecatedString("~"sv));
+(((parsed_function).name_span) = ((((*this).previous())).span()));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 43: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Caret>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+else {
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+(((parsed_function).name) = name);
+(((parsed_function).name_span) = ((((*this).current())).span()));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 44: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::CaretEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete function definition"sv),((((*this).current())).span())))));
+return (parsed_function);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 45: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dollar>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 46: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+
+((((*this).index)++));
+if ((!(is_destructor))){
+(((parsed_function).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 47: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlash>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete function"sv),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 48: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ExclamationPoint>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if ((!(is_destructor))){
+(((parsed_function).params) = TRY((((*this).parse_function_parameters()))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 49: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMark>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+bool can_throw = (((parsed_function).name) == Jakt::DeprecatedString("main"sv));
+if (((((*this).current())).index() == 99 /* Throws */)){
+if (is_destructor){
+TRY((((*this).error(Jakt::DeprecatedString("Destructor cannot throw"sv),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 50: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMark>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+else {
+(can_throw = true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 51: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMarkEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 52: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comma>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+(((parsed_function).can_throw) = can_throw);
+if (((((*this).current())).index() == 58 /* Arrow */)){
+((((*this).index)++));
+utility::Span const start = ((((*this).current())).span());
+(((parsed_function).return_type) = TRY((((*this).parse_typename()))));
+(((parsed_function).return_type_span) = TRY((parser::merge_spans(start,((((*this).previous())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 53: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+else {
+(((parsed_function).return_type_span) = ((((*this).previous())).span()));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 54: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DotDot>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+
+if (((linkage).index() == 1 /* External */)){
+return (parsed_function);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 57: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::FatArrow>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((((*this).current())).index() == 57 /* FatArrow */)){
+(((parsed_function).block) = TRY((((*this).parse_fat_arrow()))));
+(((parsed_function).is_fat_arrow) = true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 58: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Arrow>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+else {
+if (allow_missing_body){
+((*this).skip_newlines());
+if (((((*this).current())).index() == 9 /* LCurly */)){
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 59: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::And>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+else {
+return (parsed_function);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 60: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Anon>();
-utility::Span const& span = __jakt_match_value.value;
+
+}
+(((parsed_function).block) = TRY((((*this).parse_block()))));
+}
+
+return (parsed_function);
+}
+}
+
+ErrorOr<parser::ParsedExternImport> parser::Parser::parse_extern_import(parser::ParsedNamespace& parent) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+parser::ParsedExternImport parsed_import = parser::ParsedExternImport(false,parser::ParsedNamespace(JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedFunction>::create_with({})))),(TRY((DynamicArray<parser::ParsedRecord>::create_with({})))),(TRY((DynamicArray<parser::ParsedTrait>::create_with({})))),(TRY((DynamicArray<parser::ParsedExternalTraitImplementation>::create_with({})))),(TRY((DynamicArray<parser::ParsedNamespace>::create_with({})))),(TRY((DynamicArray<parser::ParsedAlias>::create_with({})))),(TRY((DynamicArray<parser::ParsedModuleImport>::create_with({})))),(TRY((DynamicArray<parser::ParsedExternImport>::create_with({})))),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),(TRY((DynamicArray<parser::IncludeAction>::create_with({}))))),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
+((((*this).index)++));
+if (((name == Jakt::DeprecatedString("c"sv)) || (name == Jakt::DeprecatedString("C"sv)))){
+(((parsed_import).is_c) = true);
 }
-return JaktInternal::ExplicitValue<void>();
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected 'c' or path after `import extern`"sv),((((*this).current())).span())))));
+}
+
+}
+DeprecatedString const import_path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<parser::ParsedExternImport>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_50; {
+((((*this).index)++));
+__jakt_var_50 = quote; goto __jakt_label_48;
+
+}
+__jakt_label_48:; __jakt_var_50.release_value(); }));
 };/*case end*/
-case 61: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::As>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+default: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_51; {
+TRY((((*this).error(Jakt::DeprecatedString("Expected path after `import extern`"sv),((((*this).current())).span())))));
+__jakt_var_51 = Jakt::DeprecatedString(""sv); goto __jakt_label_49;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_49:; __jakt_var_51.release_value(); }));
 };/*case end*/
-case 62: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Boxed>();
-utility::Span const& span = __jakt_match_value.value;
+}/*switch end*/
+}()
+));
+if (((((*this).current())).index() == 61 /* As */)){
+((((*this).index)++));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
+((((*this).index)++));
+(((((parsed_import).assigned_namespace)).name) = name);
+(((((parsed_import).assigned_namespace)).name_span) = span);
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected name after 'as' keyword to name the extern import"sv),((((*this).current())).span())))));
+}
+
+}
+if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected '{' to start namespace for the extern import"sv),((((*this).current())).span())))));
+}
+((((*this).index)++));
+(((parsed_import).assigned_namespace) = TRY((((*this).parse_namespace()))));
+(((((parsed_import).assigned_namespace)).import_path_if_extern) = static_cast<JaktInternal::Optional<DeprecatedString>>(import_path));
+(((((parsed_import).assigned_namespace)).generating_import_extern_before_include) = ((parsed_import).before_include));
+(((((parsed_import).assigned_namespace)).generating_import_extern_after_include) = ((parsed_import).after_include));
+if (((((*this).current())).index() == 10 /* RCurly */)){
+((((*this).index)++));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected '}' to end namespace for the extern import"sv),((((*this).current())).span())))));
+}
+
+for (;;){
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<parser::ParsedExternImport>>{
+auto __jakt_enum_value = (name);
+if (__jakt_enum_value == Jakt::DeprecatedString("before_include"sv)) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
+JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>> const actions = TRY((((*this).parse_include_action())));
+if (((actions).has_value())){
+TRY((((((parsed_import).before_include)).push_values((((actions.value())))))));
+}
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 63: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Break>();
-utility::Span const& span = __jakt_match_value.value;
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("after_include"sv)) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
+JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>> const actions = TRY((((*this).parse_include_action())));
+if (((actions).has_value())){
+TRY((((((parsed_import).after_include)).push_values((((actions.value())))))));
+}
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 64: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Catch>();
-utility::Span const& span = __jakt_match_value.value;
+}
+else {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 65: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Class>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 66: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Continue>();
-utility::Span const& span = __jakt_match_value.value;
+}()))
+;
+}
+else {
+break;
+}
+
+}
+TRY((((((parent))).add_child_namespace(((parsed_import).assigned_namespace)))));
+return (parsed_import);
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_typename() {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+utility::Span const start = ((((*this).current())).span());
+bool is_reference = false;
+bool is_mutable_reference = false;
+if (((((*this).current())).index() == 37 /* Ampersand */)){
+(is_reference = true);
+((((*this).index)++));
+if (((((*this).current())).index() == 84 /* Mut */)){
+(is_mutable_reference = true);
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 67: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Cpp>();
-utility::Span const& span = __jakt_match_value.value;
+}
+NonnullRefPtr<typename parser::ParsedType> parsed_type = TRY((((*this).parse_type_shorthand())));
+if (((parsed_type)->index() == 13 /* Empty */)){
+(parsed_type = TRY((((*this).parse_type_longhand()))));
+}
+if (((((*this).current())).index() == 49 /* QuestionMark */)){
+((((*this).index)++));
+utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
+(parsed_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Optional>(parsed_type,span))));
+}
+if (is_reference){
+utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
+if (is_mutable_reference){
+(parsed_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::MutableReference>(parsed_type,span))));
+}
+else {
+(parsed_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Reference>(parsed_type,span))));
+}
+
+}
+return (parsed_type);
+}
+}
+
+ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parser::Parser::parse_struct_class_body(parser::DefinitionLinkage const definition_linkage,parser::Visibility const default_visibility,bool const is_class) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((((*this).current())).index() == 9 /* LCurly */)){
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 68: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Defer>();
-utility::Span const& span = __jakt_match_value.value;
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
+}
+
+JaktInternal::DynamicArray<parser::ParsedField> fields = (TRY((DynamicArray<parser::ParsedField>::create_with({}))));
+JaktInternal::DynamicArray<parser::ParsedMethod> methods = (TRY((DynamicArray<parser::ParsedMethod>::create_with({}))));
+JaktInternal::Optional<parser::Visibility> last_visibility = JaktInternal::OptionalNone();
+JaktInternal::Optional<utility::Span> last_visibility_span = JaktInternal::OptionalNone();
+bool last_virtual = false;
+bool last_override = false;
+bool error = false;
+JaktInternal::DynamicArray<parser::ParsedAttribute> active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({}))));
+while ((!(((*this).eof())))){
+lexer::Token const token = ((*this).current());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = token;
+switch(__jakt_match_variant.index()) {
+case 10: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((last_visibility).has_value())){
+TRY((((*this).error(Jakt::DeprecatedString("Expected function or parameter after visibility modifier"sv),((token).span())))));
+}
+if ((!(((active_attributes).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected function after attribute"sv),((token).span())))));
+}
+((((*this).index)++));
+return ((Tuple{fields, methods}));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 69: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Destructor>();
-utility::Span const& span = __jakt_match_value.value;
+case 52: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 70: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Else>();
-utility::Span const& span = __jakt_match_value.value;
+case 55: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 71: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Enum>();
+case 90: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((last_visibility).has_value())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+}
+(last_visibility =  parser::Visibility { typename parser::Visibility::Public() } );
+(last_visibility_span = span);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 72: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Extern>();
+case 89: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((last_visibility).has_value())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 73: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+(last_visibility =  parser::Visibility { typename parser::Visibility::Private() } );
+(last_visibility_span = span);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 74: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::For>();
+case 94: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((last_visibility).has_value())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 76: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comptime>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+(last_visibility = TRY((((*this).parse_restricted_visibility_modifier()))));
+(last_visibility_span = span);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 77: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::If>();
-utility::Span const& span = __jakt_match_value.value;
+case 11: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 11 /* LSquare */)){
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
+TRY((((*this).parse_attribute_list(((active_attributes))))));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Unexpected token (expected ‘[[’)"sv),((((*this).current())).span())))));
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+}
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 78: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Import>();
-utility::Span const& span = __jakt_match_value.value;
+case 3: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if ((!(((active_attributes).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Attributes cannot be applied to fields"sv),((((*this).current())).span())))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+}
+parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return default_visibility; });
+(last_visibility = JaktInternal::OptionalNone());
+(last_visibility_span = JaktInternal::OptionalNone());
+if ((last_virtual || last_override)){
+TRY((((*this).error(Jakt::DeprecatedString("Fields cannot be ‘virtual’ or ‘override’"sv),((((*this).current())).span())))));
+}
+(last_virtual = false);
+(last_override = false);
+parser::ParsedField const field = TRY((((*this).parse_field(visibility))));
+TRY((((fields).push(field))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 79: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::In>();
-utility::Span const& span = __jakt_match_value.value;
+case 75: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
+bool const is_destructor = ((((*this).current())).index() == 69 /* Destructor */);
+parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = definition_linkage;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
+TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
+}
+parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return default_visibility; });
+(last_visibility = JaktInternal::OptionalNone());
+(last_visibility_span = JaktInternal::OptionalNone());
+bool const is_virtual = last_virtual;
+bool const is_override = last_override;
+(last_virtual = false);
+(last_override = false);
+parser::ParsedMethod parsed_method = TRY((((*this).parse_method(function_linkage,visibility,is_virtual,is_override,is_comptime,is_destructor))));
+TRY((((*this).apply_attributes(((parsed_method)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((methods).push(parsed_method))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 80: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Is>();
-utility::Span const& span = __jakt_match_value.value;
+case 76: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
+bool const is_destructor = ((((*this).current())).index() == 69 /* Destructor */);
+parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = definition_linkage;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
+TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
+}
+parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return default_visibility; });
+(last_visibility = JaktInternal::OptionalNone());
+(last_visibility_span = JaktInternal::OptionalNone());
+bool const is_virtual = last_virtual;
+bool const is_override = last_override;
+(last_virtual = false);
+(last_override = false);
+parser::ParsedMethod parsed_method = TRY((((*this).parse_method(function_linkage,visibility,is_virtual,is_override,is_comptime,is_destructor))));
+TRY((((*this).apply_attributes(((parsed_method)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((methods).push(parsed_method))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 81: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Let>();
-utility::Span const& span = __jakt_match_value.value;
+case 69: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
+bool const is_destructor = ((((*this).current())).index() == 69 /* Destructor */);
+parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = definition_linkage;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
+TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
+}
+parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return default_visibility; });
+(last_visibility = JaktInternal::OptionalNone());
+(last_visibility_span = JaktInternal::OptionalNone());
+bool const is_virtual = last_virtual;
+bool const is_override = last_override;
+(last_virtual = false);
+(last_override = false);
+parser::ParsedMethod parsed_method = TRY((((*this).parse_method(function_linkage,visibility,is_virtual,is_override,is_comptime,is_destructor))));
+TRY((((*this).apply_attributes(((parsed_method)),((active_attributes))))));
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+TRY((((methods).push(parsed_method))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 82: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Loop>();
-utility::Span const& span = __jakt_match_value.value;
+case 103: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+(last_virtual = true);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 83: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Match>();
-utility::Span const& span = __jakt_match_value.value;
+case 88: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+(last_override = true);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 84: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Mut>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+if ((!(error))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Invalid member, did not expect a {} here"sv),token))),((token).span())))));
+(error = true);
+}
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 85: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Namespace>();
-utility::Span const& span = __jakt_match_value.value;
+}/*switch end*/
+}()
+));
+}
+if (is_class){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete class body, expected ‘}’"sv),((((*this).current())).span())))));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct body, expected ‘}’"sv),((((*this).current())).span())))));
+}
+
+return ((Tuple{fields, methods}));
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_range() {
+{
+utility::Span const start = ((((*this).current())).span());
+((((*this).index)++));
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> to = JaktInternal::OptionalNone();
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 12: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 86: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
-utility::Span const& span = __jakt_match_value.value;
+case 55: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 87: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Or>();
-utility::Span const& span = __jakt_match_value.value;
+case 52: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 88: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Override>();
-utility::Span const& span = __jakt_match_value.value;
+case 8: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 89: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+(to = TRY((((*this).parse_operand()))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 90: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+}/*switch end*/
+}()
+));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Range>(JaktInternal::OptionalNone(),to,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 91: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Raw>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 92: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<parser::ParsedNamespace> parser::Parser::parse(NonnullRefPtr<compiler::Compiler> const compiler,JaktInternal::DynamicArray<lexer::Token> const tokens) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+parser::Parser parser = parser::Parser(static_cast<size_t>(0ULL),tokens,compiler,true);
+return (TRY((((parser).parse_namespace()))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 93: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Return>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 94: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<JaktInternal::Optional<parser::NumericConstant>> parser::Parser::make_float_numeric_constant(f64 const number,lexer::LiteralSuffix const suffix,utility::Span const span) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
-}
-return JaktInternal::ExplicitValue<void>();
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<parser::NumericConstant>, ErrorOr<JaktInternal::Optional<parser::NumericConstant>>>{
+auto&& __jakt_match_variant = suffix;
+switch(__jakt_match_variant.index()) {
+case 10: {
+return JaktInternal::ExplicitValue( parser::NumericConstant { typename parser::NumericConstant::F32(parser::f64_to_f32(number)) } );
 };/*case end*/
-case 95: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
-}
-return JaktInternal::ExplicitValue<void>();
+case 11: {
+return JaktInternal::ExplicitValue( parser::NumericConstant { typename parser::NumericConstant::F64(number) } );
 };/*case end*/
-case 96: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Struct>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
-}
-return JaktInternal::ExplicitValue<void>();
+default: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
 };/*case end*/
-case 97: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+}/*switch end*/
+}()
+)));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 98: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throw>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 99: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throws>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<parser::ParsedBlock> parser::Parser::parse_fat_arrow() {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
+utility::Span const start = ((((*this).current())).span());
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+NonnullRefPtr<typename parser::ParsedStatement> const return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(expr,TRY((parser::merge_spans(start,((((*this).current())).span())))))));
+return (parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({return_statement}))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 100: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 101: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
-utility::Span const& span = __jakt_match_value.value;
+
+void parser::Parser::skip_newlines() {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+while (((((*this).current())).index() == 55 /* Eol */)){
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 102: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Unsafe>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 103: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Virtual>();
-utility::Span const& span = __jakt_match_value.value;
+}
+
+lexer::Token parser::Parser::previous() const {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((((*this).index) == static_cast<size_t>(0ULL)) || (((*this).index) > ((((*this).tokens)).size())))){
+return ( lexer::Token { typename lexer::Token::Eof(((*this).span(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)))) } );
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 104: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Weak>();
-utility::Span const& span = __jakt_match_value.value;
+return (((((*this).tokens))[(JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL)))]));
+}
+}
+
+ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parser::Parser::parse_value_enum_body(parser::ParsedRecord const partial_enum,parser::DefinitionLinkage const definition_linkage) {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+JaktInternal::DynamicArray<parser::ParsedMethod> methods = (TRY((DynamicArray<parser::ParsedMethod>::create_with({}))));
+JaktInternal::DynamicArray<parser::ValueEnumVariant> variants = (TRY((DynamicArray<parser::ValueEnumVariant>::create_with({}))));
+if (((((*this).current())).index() == 9 /* LCurly */)){
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 105: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::While>();
-utility::Span const& span = __jakt_match_value.value;
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected `{` to start the enum body"sv),((((*this).current())).span())))));
+}
+
+((*this).skip_newlines());
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected variant name"sv),((((*this).previous())).span())))));
+return ((Tuple{variants, methods}));
+}
+JaktInternal::Optional<parser::Visibility> last_visibility = JaktInternal::OptionalNone();
+JaktInternal::Optional<utility::Span> last_visibility_span = JaktInternal::OptionalNone();
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 16 /* Equal */)){
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+TRY((((variants).push(parser::ValueEnumVariant(name,span,expr)))));
+}
+else {
+((((*this).index)++));
+TRY((((variants).push(parser::ValueEnumVariant(name,span,JaktInternal::OptionalNone())))));
+}
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 106: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Yield>();
-utility::Span const& span = __jakt_match_value.value;
+case 10: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 107: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Guard>();
-utility::Span const& span = __jakt_match_value.value;
+case 52: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 108: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Implements>();
-utility::Span const& span = __jakt_match_value.value;
+case 55: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 109: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Requires>();
+case 89: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((last_visibility).has_value())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+}
+(last_visibility =  parser::Visibility { typename parser::Visibility::Private() } );
+(last_visibility_span = span);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 110: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Trait>();
+case 90: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
+if (((last_visibility).has_value())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+}
+(last_visibility =  parser::Visibility { typename parser::Visibility::Public() } );
+(last_visibility_span = span);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 111: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Garbage>();utility::Span const& span = __jakt_match_value.span;
+case 75: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
-return (parsed_trait);
-}
-return JaktInternal::ExplicitValue<void>();
+bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
+parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = definition_linkage;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
+if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
+TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
 }
-return (parsed_trait);
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '{' to enter the body of the trait"sv),((((*this).current())).span())))));
-return (parsed_trait);
+parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; });
+(last_visibility = JaktInternal::OptionalNone());
+(last_visibility_span = JaktInternal::OptionalNone());
+parser::ParsedMethod const parsed_method = TRY((((*this).parse_method(function_linkage,visibility,false,false,is_comptime,false))));
+TRY((((methods).push(parsed_method))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 76: {
+{
+bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
+parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = definition_linkage;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
+TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),((((*this).current())).span())))));
-return (parsed_trait);
+parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; });
+(last_visibility = JaktInternal::OptionalNone());
+(last_visibility_span = JaktInternal::OptionalNone());
+parser::ParsedMethod const parsed_method = TRY((((*this).parse_method(function_linkage,visibility,false,false,is_comptime,false))));
+TRY((((methods).push(parsed_method))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or the end of enum block"sv),((((*this).current())).span())))));
+((((*this).index)++));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+}
+if ((!(((((*this).current())).index() == 10 /* RCurly */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Invalid enum definition, expected `}`"sv),((((*this).current())).span())))));
+return ((Tuple{variants, methods}));
+}
+((((*this).index)++));
+if (((variants).is_empty())){
+TRY((((*this).error(Jakt::DeprecatedString("Empty enums are not allowed"sv),((partial_enum).name_span)))));
+}
+return ((Tuple{variants, methods}));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_number(lexer::LiteralPrefix const prefix,DeprecatedString const number,lexer::LiteralSuffix suffix,utility::Span const span) {
+ErrorOr<JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>>> parser::Parser::parse_type_parameter_list() {
 {
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> params = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))));
+if (((((*this).current())).index() == 28 /* LessThan */)){
 ((((*this).index)++));
-u64 total = static_cast<u64>(0ULL);
-if ((!(((prefix).index() == 0 /* None */)))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = prefix;
+bool saw_ending_bracket = false;
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>>>>{
+auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 1: {
+case 26: {
 {
-if ((((number).length()) == static_cast<size_t>(0ULL))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not parse hexadecimal number due to no digits"sv)))),span))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
+((((*this).index)++));
+(saw_ending_bracket = true);
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 33: {
 {
-DeprecatedStringCodePointIterator _magic = ((number).code_points());
-for (;;){
-JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).inject_token( lexer::Token { typename lexer::Token::GreaterThan(((((*this).current())).span())) } ))));
+((((*this).index)++));
+(saw_ending_bracket = true);
+return JaktInternal::LoopBreak{};
 }
-u32 cp = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-u8 const byte = as_saturated<u8, u32>(cp);
-if ((byte != '_')){
-u8 offset = static_cast<u8>(0);
-if (((byte >= 'a') && (byte <= 'z'))){
-(offset = static_cast<u8>(39));
+size_t index_before = ((*this).index);
+TRY((((params).push(TRY((((*this).parse_typename())))))));
+if ((((*this).index) == index_before)){
+TRY((((*this).error(Jakt::DeprecatedString("Expected type parameter"sv),((((*this).current())).span())))));
+return JaktInternal::LoopBreak{};
 }
-else if (((byte >= 'A') && (byte <= 'Z'))){
-(offset = static_cast<u8>(7));
+if (((((*this).current())).index() == 52 /* Comma */)){
+((((*this).index)++));
 }
-u8 const value = (JaktInternal::checked_sub<u8>(byte,offset));
-u64 const digit = as_saturated<u64, u8>((JaktInternal::checked_sub<u8>(value,'0')));
-(total = (JaktInternal::checked_add<u64>((JaktInternal::checked_mul<u64>(total,static_cast<u64>(16ULL))),digit)));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+}
+if ((!(saw_ending_bracket))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected `>` after type parameters"sv),((((*this).current())).span())))));
 }
-
+}
+return (params);
 }
 }
 
+ErrorOr<JaktInternal::DynamicArray<parser::EnumVariantPatternArgument>> parser::Parser::parse_variant_arguments() {
+{
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments = (TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({}))));
+bool has_parens = false;
+if (((((*this).current())).index() == 7 /* LParen */)){
+(has_parens = true);
+((((*this).index)++));
+bool is_reference = false;
+bool is_mutable = false;
+while ((!(((*this).eof())))){
+((*this).skip_newlines());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::EnumVariantPatternArgument>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 37: {
+{
+(is_reference = true);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-{
-if ((((number).length()) == static_cast<size_t>(0ULL))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not parse octal number due to no digits"sv)))),span))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
-}
+case 84: {
 {
-DeprecatedStringCodePointIterator _magic = ((number).code_points());
-for (;;){
-JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(is_mutable = true);
+((((*this).index)++));
 }
-u32 cp = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& arg_name = __jakt_match_value.name;
 {
-u8 const byte = as_saturated<u8, u32>(cp);
-if ((byte != '_')){
-u64 const digit = as_saturated<u64, u8>((JaktInternal::checked_sub<u8>(byte,'0')));
-(total = (JaktInternal::checked_add<u64>((JaktInternal::checked_mul<u64>(total,static_cast<u64>(8ULL))),digit)));
+if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 5 /* Colon */)){
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const arg_binding = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const span = ((((*this).current())).span());
+((((*this).index)++));
+TRY((((variant_arguments).push(parser::EnumVariantPatternArgument(static_cast<JaktInternal::Optional<DeprecatedString>>(arg_name),arg_binding,span,is_reference,is_mutable)))));
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected binding after ‘:’"sv),((((*this).current())).span())))));
 }
 
 }
+else {
+TRY((((variant_arguments).push(parser::EnumVariantPatternArgument(JaktInternal::OptionalNone(),arg_name,((((*this).current())).span()),is_reference,is_mutable)))));
+((((*this).index)++));
 }
 
+(is_reference = false);
+(is_mutable = false);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
+case 52: {
 {
-if ((((number).length()) == static_cast<size_t>(0ULL))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not parse binary number due to no digits"sv)))),span))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
+((((*this).index)++));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 8: {
 {
-DeprecatedStringCodePointIterator _magic = ((number).code_points());
-for (;;){
-JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
-u32 cp = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-u8 const byte = as_saturated<u8, u32>(cp);
-if ((byte != '_')){
-u64 const digit = as_saturated<u64, u8>((JaktInternal::checked_sub<u8>(byte,'0')));
-(total = (JaktInternal::checked_add<u64>((JaktInternal::checked_mul<u64>(total,static_cast<u64>(2ULL))),digit)));
+TRY((((*this).error(Jakt::DeprecatedString("Expected pattern argument name"sv),((((*this).current())).span())))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+}
+}
+return (variant_arguments);
 }
 }
 
+ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parser::Parser::parse_guard_statement() {
+{
+utility::Span const span = ((((*this).current())).span());
+((((*this).index)++));
+bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
+(((*this).can_have_trailing_closure) = false);
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,true))));
+(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
+if (((((*this).current())).index() == 70 /* Else */)){
+((((*this).index)++));
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected `else` keyword"sv),((((*this).current())).span())))));
 }
 
+parser::ParsedBlock const else_block = TRY((((*this).parse_block())));
+parser::ParsedBlock remaining_code = parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({})))));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 10: {
+{
+return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Guard>(expr,else_block,remaining_code,span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 0: {
+case 4: {
 {
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+case 55: {
+{
+((((*this).index)++));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+TRY((((((remaining_code).stmts)).push(TRY((((*this).parse_statement(true))))))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
 }()
 ));
-JaktInternal::Optional<parser::NumericConstant> const constant_value = TRY((((*this).make_integer_numeric_constant(total,suffix,span))));
-if (((constant_value).has_value())){
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::NumericConstant>((constant_value.value()),span))));
 }
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
+return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Guard>(expr,else_block,remaining_code,span))));
 }
-bool number_too_large = false;
-bool floating = false;
-u64 fraction_nominator = static_cast<u64>(0ULL);
-u64 fraction_denominator = static_cast<u64>(1ULL);
-if ((((number).length()) == static_cast<size_t>(0ULL))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not parse number due to no digits"sv)))),span))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
+
+bool parser::Parser::eof() const {
 {
-DeprecatedStringCodePointIterator _magic = ((number).code_points());
+return ((((*this).index) >= (JaktInternal::checked_sub<size_t>(((((*this).tokens)).size()),static_cast<size_t>(1ULL)))));
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_asterisk() {
+{
+utility::Span const start = ((((*this).current())).span());
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::Dereference() } ,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_match_expression() {
+{
+utility::Span start = ((((*this).current())).span());
+((((*this).index)++));
+bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
+(((*this).can_have_trailing_closure) = false);
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,true))));
+(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
+JaktInternal::DynamicArray<parser::ParsedMatchCase> const cases = TRY((((*this).parse_match_cases())));
+if ((((cases).size()) > static_cast<size_t>(1ULL))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>((JaktInternal::checked_sub<size_t>(((cases).size()),static_cast<size_t>(1ULL))))});
 for (;;){
-JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-u32 cp = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-u8 const byte = as_saturated<u8, u32>(cp);
-if ((byte != '_')){
-if ((byte == '.')){
-(floating = true);
-continue;
-}
-u64 const digit = as_saturated<u64, u8>((JaktInternal::checked_sub<u8>(byte,'0')));
-if (floating){
-(fraction_nominator = (JaktInternal::checked_add<u64>((JaktInternal::checked_mul<u64>(fraction_nominator,static_cast<u64>(10ULL))),digit)));
-({auto& _jakt_ref = fraction_denominator;_jakt_ref = JaktInternal::checked_mul<u64>(_jakt_ref, static_cast<u64>(10ULL));});
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>((JaktInternal::checked_add<size_t>(i,static_cast<size_t>(1ULL)))),static_cast<size_t>(((cases).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-u64 const old_total = total;
-(total = unchecked_add<u64>(unchecked_mul<u64>(total,static_cast<u64>(10ULL)),digit));
-if ((total < old_total)){
-(number_too_large = true);
+size_t k = (_magic_value.value());
+{
+if (((((cases)[i])).has_equal_pattern(((cases)[k])))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Duplicated match pattern"sv),((((cases)[k])).marker_span),Jakt::DeprecatedString("Original pattern here"sv),((((cases)[i])).marker_span)))));
 }
 }
 
 }
 }
 
-}
 }
 
-if (number_too_large){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Integer literal too large"sv)))),span))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
-}
-if ((floating && ((suffix).index() == 0 /* None */))){
-(suffix =  lexer::LiteralSuffix { typename lexer::LiteralSuffix::F64() } );
-}
-bool const is_float_suffix = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = suffix;
-switch(__jakt_match_variant.index()) {
-case 10: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-));
-if ((floating && (!(is_float_suffix)))){
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
-JaktInternal::Optional<parser::NumericConstant> const constant_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<parser::NumericConstant>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = suffix;
-switch(__jakt_match_variant.index()) {
-case 10: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<parser::NumericConstant>> __jakt_var_67; {
-f64 const number = (parser::u64_to_float<f64>(total) + (parser::u64_to_float<f64>(fraction_nominator) / parser::u64_to_float<f64>(fraction_denominator)));
-__jakt_var_67 = TRY((((*this).make_float_numeric_constant(number,suffix,span)))); goto __jakt_label_64;
-
 }
-__jakt_label_64:; __jakt_var_67.release_value(); }));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<parser::NumericConstant>> __jakt_var_68; {
-f64 const number = (parser::u64_to_float<f64>(total) + (parser::u64_to_float<f64>(fraction_nominator) / parser::u64_to_float<f64>(fraction_denominator)));
-__jakt_var_68 = TRY((((*this).make_float_numeric_constant(number,suffix,span)))); goto __jakt_label_65;
 
 }
-__jakt_label_65:; __jakt_var_68.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(TRY((((*this).make_integer_numeric_constant(total,suffix,span)))));
-};/*case end*/
-}/*switch end*/
-}()
-));
-if (((constant_value).has_value())){
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::NumericConstant>((constant_value.value()),span))));
-}
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Match>(expr,cases,TRY((parser::merge_spans(start,((((*this).previous())).span())))),start))));
 }
 }
 
@@ -5823,7 +5543,7 @@ break;
 }
 parser::ParsedParameter param = (_magic_value.value());
 {
-ScopeGuard __jakt_var_69([&] {
+ScopeGuard __jakt_var_52([&] {
 ({auto& _jakt_ref = index;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 });
 if ((((((param).variable)).name) == ((argument).name))){
@@ -5938,1319 +5658,1381 @@ return JaktInternal::ExplicitValue<void>();
 return {};
 }
 
-utility::Span parser::Parser::span(size_t const start,size_t const end) const {
+lexer::Token parser::Parser::current() const {
 {
-return (utility::Span((((((*this).compiler))->current_file).value()),start,end));
+return (((*this).peek(static_cast<size_t>(0ULL))));
 }
 }
 
-ErrorOr<parser::ParsedFunction> parser::Parser::parse_function(parser::FunctionLinkage const linkage,parser::Visibility const visibility,bool const is_comptime,bool const is_destructor,bool const allow_missing_body) {
+ErrorOr<parser::ParsedRecord> parser::Parser::parse_enum(parser::DefinitionLinkage const definition_linkage,bool const is_boxed) {
 {
-parser::ParsedFunction parsed_function = parser::ParsedFunction(Jakt::DeprecatedString(""sv),((*this).empty_span()),visibility,(TRY((DynamicArray<parser::ParsedParameter>::create_with({})))),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({}))))),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),((*this).span(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL))),false, parser::FunctionType { typename parser::FunctionType::Normal() } ,linkage,false,is_comptime,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone());
-if (is_destructor){
-(((parsed_function).type) =  parser::FunctionType { typename parser::FunctionType::Destructor() } );
-TRY((((((parsed_function).params)).push(parser::ParsedParameter(false,parser::ParsedVariable(Jakt::DeprecatedString("this"sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),true,((((*this).current())).span())),JaktInternal::OptionalNone(),((((*this).current())).span()))))));
-}
-if ((!(is_destructor))){
+parser::ParsedRecord parsed_enum = parser::ParsedRecord(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),definition_linkage,JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedMethod>::create_with({})))), parser::RecordType { typename parser::RecordType::Garbage() } ,JaktInternal::OptionalNone());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> underlying_type = JaktInternal::OptionalNone();
+if (((((*this).current())).index() == 71 /* Enum */)){
 ((((*this).index)++));
 }
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete function definition"sv),((((*this).current())).span())))));
-return (parsed_function);
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘enum’ keyword"sv),((((*this).current())).span())))));
+return (parsed_enum);
 }
-if (is_destructor){
-(((parsed_function).name) = Jakt::DeprecatedString("~"sv));
-(((parsed_function).name_span) = ((((*this).previous())).span()));
+
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected name"sv),((((*this).current())).span())))));
+return (parsed_enum);
 }
-else {
 if (((((*this).current())).index() == 3 /* Identifier */)){
 DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-(((parsed_function).name) = name);
-(((parsed_function).name_span) = ((((*this).current())).span()));
+utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
+(((parsed_enum).name) = name);
+(((parsed_enum).name_span) = span);
+((((*this).index)++));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete function definition"sv),((((*this).current())).span())))));
-return (parsed_function);
-}
-
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected name"sv),((((*this).current())).span())))));
 }
 
-((((*this).index)++));
-if ((!(is_destructor))){
-(((parsed_function).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
-}
 if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete function"sv),((((*this).current())).span())))));
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected generic parameters or underlying type or body"sv),((((*this).current())).span())))));
+return (parsed_enum);
 }
-if ((!(is_destructor))){
-(((parsed_function).params) = TRY((((*this).parse_function_parameters()))));
+if (((((*this).current())).index() == 28 /* LessThan */)){
+(((parsed_enum).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
 }
-bool can_throw = (((parsed_function).name) == Jakt::DeprecatedString("main"sv));
-if (((((*this).current())).index() == 99 /* Throws */)){
-if (is_destructor){
-TRY((((*this).error(Jakt::DeprecatedString("Destructor cannot throw"sv),((((*this).current())).span())))));
+if (((((*this).current())).index() == 108 /* Implements */)){
+((((*this).index)++));
+(((parsed_enum).implements_list) = TRY((((*this).parse_trait_list()))));
 }
-else {
-(can_throw = true);
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected underlying type or body"sv),((((*this).current())).span())))));
+return (parsed_enum);
 }
-
-((((*this).index)++));
+if (((((*this).current())).index() == 5 /* Colon */)){
+if (is_boxed){
+TRY((((*this).error(Jakt::DeprecatedString("Invalid enum definition: Value enums must not have an underlying type"sv),((((*this).current())).span())))));
 }
-(((parsed_function).can_throw) = can_throw);
-if (((((*this).current())).index() == 58 /* Arrow */)){
 ((((*this).index)++));
-utility::Span const start = ((((*this).current())).span());
-(((parsed_function).return_type) = TRY((((*this).parse_typename()))));
-(((parsed_function).return_type_span) = TRY((parser::merge_spans(start,((((*this).previous())).span())))));
+(underlying_type = TRY((((*this).parse_typename()))));
 }
-else {
-(((parsed_function).return_type_span) = ((((*this).previous())).span()));
+((*this).skip_newlines());
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected body"sv),((((*this).current())).span())))));
+return (parsed_enum);
 }
+if (((underlying_type).has_value())){
+JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>> const variants_methods_ = TRY((((*this).parse_value_enum_body(parsed_enum,definition_linkage))));
+JaktInternal::DynamicArray<parser::ValueEnumVariant> const variants = ((variants_methods_).template get<0>());
+JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((variants_methods_).template get<1>());
 
-if (((linkage).index() == 1 /* External */)){
-return (parsed_function);
-}
-if (((((*this).current())).index() == 57 /* FatArrow */)){
-(((parsed_function).block) = TRY((((*this).parse_fat_arrow()))));
-(((parsed_function).is_fat_arrow) = true);
-}
-else {
-if (allow_missing_body){
-((*this).skip_newlines());
-if (((((*this).current())).index() == 9 /* LCurly */)){
+(((parsed_enum).methods) = methods);
+(((parsed_enum).record_type) =  parser::RecordType { typename parser::RecordType::ValueEnum((underlying_type.value()),variants) } );
 }
 else {
-return (parsed_function);
-}
+JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>> const variants_fields_methods_ = TRY((((*this).parse_sum_enum_body(parsed_enum,definition_linkage,is_boxed))));
+JaktInternal::DynamicArray<parser::SumEnumVariant> const variants = ((variants_fields_methods_).template get<0>());
+JaktInternal::DynamicArray<parser::ParsedField> const fields = ((variants_fields_methods_).template get<1>());
+JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((variants_fields_methods_).template get<2>());
 
-}
-(((parsed_function).block) = TRY((((*this).parse_block()))));
+(((parsed_enum).methods) = methods);
+(((parsed_enum).record_type) =  parser::RecordType { typename parser::RecordType::SumEnum(is_boxed,fields,variants) } );
 }
 
-return (parsed_function);
+return (parsed_enum);
 }
 }
 
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>> parser::Parser::parse_include_action() {
-{
-((*this).skip_newlines());
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>>>{
-auto __jakt_enum_value = (name);
-if (__jakt_enum_value == Jakt::DeprecatedString("define"sv)) {
+ErrorOr<parser::ParsedBlock> parser::Parser::parse_block() {
 {
-((((*this).index)++));
+utility::Span const start = ((((*this).current())).span());
+parser::ParsedBlock block = parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({})))));
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete block"sv),start))));
+return (block);
+}
 ((*this).skip_newlines());
 if (((((*this).current())).index() == 9 /* LCurly */)){
 ((((*this).index)++));
-((*this).skip_newlines());
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '{' to start define action"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
+TRY((((*this).error(Jakt::DeprecatedString("Expected '{'"sv),start))));
 }
 
-JaktInternal::DynamicArray<parser::IncludeAction> defines = (TRY((DynamicArray<parser::IncludeAction>::create_with({}))));
-for (;;){
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).span());
-((((*this).index)++));
-((*this).skip_newlines());
-if (((((*this).current())).index() == 16 /* Equal */)){
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedBlock>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 10: {
+{
 ((((*this).index)++));
+return (block);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '=' to assign value to defined symbols"sv),((((*this).current())).span())))));
-continue;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 4: {
+{
+((((*this).index)++));
 }
-
-DeprecatedString const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_70; {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 55: {
+{
 ((((*this).index)++));
-__jakt_var_70 = quote; goto __jakt_label_66;
-
 }
-__jakt_label_66:; __jakt_var_70.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_71; {
-TRY((((*this).error(Jakt::DeprecatedString("Expected quoted string to assign value to defined symbols"sv),((((*this).current())).span())))));
-__jakt_var_71 = Jakt::DeprecatedString(""sv); goto __jakt_label_67;
-
+{
+TRY((((((block).stmts)).push(TRY((((*this).parse_statement(true))))))));
 }
-__jakt_label_67:; __jakt_var_71.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-TRY((((defines).push( parser::IncludeAction { typename parser::IncludeAction::Define(name,span,value) } ))));
-((*this).skip_newlines());
-if (((((*this).current())).index() == 52 /* Comma */)){
-((((*this).index)++));
-((*this).skip_newlines());
 }
+TRY((((*this).error(Jakt::DeprecatedString("Expected complete block"sv),((((*this).current())).span())))));
+return (block);
 }
-else {
-break;
 }
 
+utility::Span parser::Parser::empty_span() const {
+{
+return (((*this).span(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL))));
 }
-if (((((*this).current())).index() == 10 /* RCurly */)){
-((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '}' to end define action"sv),((((*this).current())).span())))));
 }
 
-return (static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>>(defines));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("undefine"sv)) {
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_postfix_colon_colon(utility::Span const start,NonnullRefPtr<typename parser::ParsedExpression> const expr) {
 {
 ((((*this).index)++));
-((*this).skip_newlines());
-if (((((*this).current())).index() == 9 /* LCurly */)){
-((((*this).index)++));
-((*this).skip_newlines());
+JaktInternal::DynamicArray<DeprecatedString> namespace_ = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+if (((expr)->index() == 9 /* Var */)){
+DeprecatedString const name = ((expr)->get<parser::ParsedExpression::Var>()).name;
+TRY((((namespace_).push(name))));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '{' to start undefine include action"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
+TRY((((*this).error(Jakt::DeprecatedString("Expected namespace"sv),((expr)->span())))));
 }
 
-JaktInternal::DynamicArray<parser::IncludeAction> defines = (TRY((DynamicArray<parser::IncludeAction>::create_with({}))));
-for (;;){
+while ((!(((*this).eof())))){
 if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).span());
-((((*this).index)++));
-TRY((((defines).push( parser::IncludeAction { typename parser::IncludeAction::Undefine(name,span) } ))));
-((*this).skip_newlines());
-if (((((*this).current())).index() == 52 /* Comma */)){
+DeprecatedString const current_name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
 ((((*this).index)++));
-((*this).skip_newlines());
+if (((((*this).current())).index() == 7 /* LParen */)){
+((((*this).index)--));
+JaktInternal::Optional<parser::ParsedCall> call = TRY((((*this).parse_call())));
+((((call.value())).namespace_) = namespace_);
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>((call.value()),TRY((parser::merge_spans(((expr)->span()),((((*this).current())).span()))))))));
+}
+if (((((*this).current())).index() == 28 /* LessThan */)){
+((((*this).index)--));
+JaktInternal::Optional<parser::ParsedCall> const maybe_call = TRY((((*this).parse_call())));
+if (((maybe_call).has_value())){
+parser::ParsedCall call = (maybe_call.value());
+(((call).namespace_) = namespace_);
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>(call,TRY((parser::merge_spans(((expr)->span()),((((*this).current())).span()))))))));
+}
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))));
 }
+if (((((*this).current())).index() == 6 /* ColonColon */)){
+if (((((*this).previous())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).previous())).get<lexer::Token::Identifier>()).name;
+TRY((((namespace_).push(name))));
 }
 else {
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected namespace"sv),((expr)->span())))));
 }
 
-}
-if (((((*this).current())).index() == 10 /* RCurly */)){
 ((((*this).index)++));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '}' to end undefine action"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::NamespacedVar>(current_name,namespace_,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
 }
 
-return (static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>>(defines));
-}
-return JaktInternal::ExplicitValue<void>();
 }
 else {
-{
+TRY((((*this).error(Jakt::DeprecatedString("Unsupported static method call"sv),((((*this).current())).span())))));
+return (expr);
 }
-return JaktInternal::ExplicitValue<void>();
+
 }
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-TRY((((*this).error(Jakt::DeprecatedString("Expected 'define' or 'undefine' in include action"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete static method call"sv),((((*this).current())).span())))));
+return (expr);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected 'define' or 'undefine' in include action"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
 }
 
+ErrorOr<void> parser::Parser::error(DeprecatedString const message,utility::Span const span) {
+{
+if ((!(((((*this).compiler))->ignore_parser_errors)))){
+TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::Message(message,span) } ))));
+}
 }
+return {};
 }
 
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_range() {
+ErrorOr<parser::ParsedTrait> parser::Parser::parse_trait() {
 {
-utility::Span const start = ((((*this).current())).span());
+parser::ParsedTrait parsed_trait = parser::ParsedTrait(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),(TRY((DynamicArray<parser::ParsedFunction>::create_with({})))));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const name_span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
+(((parsed_trait).name) = name);
+(((parsed_trait).name_span) = name_span);
 ((((*this).index)++));
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> to = JaktInternal::OptionalNone();
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+if (((((*this).current())).index() == 28 /* LessThan */)){
+(((parsed_trait).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
+}
+if (((((*this).current())).index() == 9 /* LCurly */)){
+((((*this).index)++));
+for (;;){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedTrait>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 12: {
+case 10: {
 {
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 56: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Eof>();
+utility::Span const& span = __jakt_match_value.value;
 {
+TRY((((*this).error(Jakt::DeprecatedString("Expected '}' to close the trait body"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 55: {
 {
+((((*this).index)++));
+return JaktInternal::LoopContinue{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 8: {
+case 75: {
 {
+parser::ParsedFunction method = TRY((((*this).parse_function( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } , parser::Visibility { typename parser::Visibility::Public() } ,false,false,true))));
+if (((((((method).block)).stmts)).is_empty())){
+(((method).linkage) =  parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
+}
+TRY((((((parsed_trait).methods)).push(method))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
 {
-(to = TRY((((*this).parse_operand()))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Range>(JaktInternal::OptionalNone(),to,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
-}
-}
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parser::Parser::parse_guard_statement() {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();utility::Span const& span = __jakt_match_value.span;
 {
-utility::Span const span = ((((*this).current())).span());
-((((*this).index)++));
-bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
-(((*this).can_have_trailing_closure) = false);
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,true))));
-(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
-if (((((*this).current())).index() == 70 /* Else */)){
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected `else` keyword"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();utility::Span const& span = __jakt_match_value.span;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-parser::ParsedBlock const else_block = TRY((((*this).parse_block())));
-parser::ParsedBlock remaining_code = parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({})))));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 10: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();utility::Span const& span = __jakt_match_value.span;
 {
-return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Guard>(expr,else_block,remaining_code,span))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Semicolon>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Colon>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ColonColon>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((((remaining_code).stmts)).push(TRY((((*this).parse_statement(true))))))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Guard>(expr,else_block,remaining_code,span))));
-}
-}
-
-ErrorOr<void> parser::Parser::inject_token(lexer::Token const token) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((((*this).tokens)).insert((JaktInternal::checked_add<size_t>(((*this).index),static_cast<size_t>(1ULL))),token))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-return {};
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RParen>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>> parser::Parser::parse_attribute() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LCurly>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const span = ((((*this).current())).span());
-DeprecatedString const name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_72; {
-((((*this).index)++));
-__jakt_var_72 = name; goto __jakt_label_68;
-
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_68:; __jakt_var_72.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 97: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_73; {
-((((*this).index)++));
-__jakt_var_73 = Jakt::DeprecatedString("this"sv); goto __jakt_label_69;
-
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LSquare>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_69:; __jakt_var_73.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RSquare>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected identifier"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<parser::ParsedAttributeArgument> arguments = (TRY((DynamicArray<parser::ParsedAttributeArgument>::create_with({}))));
-if (((((*this).current())).index() == 7 /* LParen */)){
-((((*this).index)++));
-while (((!(((*this).eof()))) && (!(((((*this).current())).index() == 8 /* RParen */))))){
-utility::Span const span = ((((*this).current())).span());
-DeprecatedString const argument_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_74; {
-((((*this).index)++));
-__jakt_var_74 = name; goto __jakt_label_70;
-
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSign>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_70:; __jakt_var_74.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 97: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_75; {
-((((*this).index)++));
-__jakt_var_75 = Jakt::DeprecatedString("this"sv); goto __jakt_label_71;
-
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Plus>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_71:; __jakt_var_75.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_76; {
-((((*this).index)++));
-__jakt_var_76 = quote; goto __jakt_label_72;
-
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_72:; __jakt_var_76.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Equal>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or string literal"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::Optional<DeprecatedString> argument_value = JaktInternal::OptionalNone();
-if (((((*this).current())).index() == 5 /* Colon */)){
-((((*this).index)++));
-(argument_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<DeprecatedString>, ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_77; {
-((((*this).index)++));
-__jakt_var_77 = name; goto __jakt_label_73;
-
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_73:; __jakt_var_77.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 97: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_78; {
-((((*this).index)++));
-__jakt_var_78 = Jakt::DeprecatedString("this"sv); goto __jakt_label_74;
-
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_74:; __jakt_var_78.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_79; {
-((((*this).index)++));
-__jakt_var_79 = quote; goto __jakt_label_75;
-
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_75:; __jakt_var_79.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or string literal"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
-}
-TRY((((arguments).push(parser::ParsedAttributeArgument(argument_name,span,argument_value)))));
-if (((((*this).current())).index() == 52 /* Comma */)){
-((((*this).index)++));
-}
-else if ((!(((((*this).current())).index() == 8 /* RParen */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘,’ or ‘)’"sv),((((*this).current())).span())))));
-break;
-}
-}
-if (((((*this).current())).index() == 8 /* RParen */)){
-((((*this).index)++));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AsteriskEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘)’"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlashEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSignEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-JaktInternal::Optional<DeprecatedString> assigned_value = JaktInternal::OptionalNone();
-if (((((*this).current())).index() == 16 /* Equal */)){
-((((*this).index)++));
-(assigned_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<DeprecatedString>, ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_80; {
-((((*this).index)++));
-__jakt_var_80 = static_cast<JaktInternal::Optional<DeprecatedString>>(name); goto __jakt_label_76;
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::NotEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_76:; __jakt_var_80.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 97: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_81; {
-((((*this).index)++));
-__jakt_var_81 = Jakt::DeprecatedString("this"sv); goto __jakt_label_77;
-
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DoubleEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_77:; __jakt_var_81.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_82; {
-((((*this).index)++));
-__jakt_var_82 = static_cast<JaktInternal::Optional<DeprecatedString>>(quote); goto __jakt_label_78;
-
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThan>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_78:; __jakt_var_82.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_83; {
-TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or string literal"sv),((((*this).current())).span())))));
-__jakt_var_83 = JaktInternal::OptionalNone(); goto __jakt_label_79;
-
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThanOrEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_79:; __jakt_var_83; }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThan>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-return (parser::ParsedAttribute(name,span,assigned_value,arguments));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThanOrEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 30: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftArithmeticShift>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_operator(bool const allow_assignments) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 31: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShift>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const span = ((((*this).current())).span());
-parser::BinaryOperator const op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::BinaryOperator, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 50: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::NoneCoalescing() } );
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Add() } );
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Subtract() } );
-};/*case end*/
-case 36: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Multiply() } );
-};/*case end*/
-case 47: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Divide() } );
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Modulo() } );
-};/*case end*/
-case 59: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::LogicalAnd() } );
-};/*case end*/
-case 87: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::LogicalOr() } );
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Equal() } );
-};/*case end*/
-case 24: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::NotEqual() } );
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::LessThan() } );
-};/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::LessThanOrEqual() } );
-};/*case end*/
-case 26: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::GreaterThan() } );
-};/*case end*/
-case 27: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::GreaterThanOrEqual() } );
-};/*case end*/
-case 37: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseAnd() } );
-};/*case end*/
-case 39: {
-return JaktInternal::ExplicitValue(({ Optional<parser::BinaryOperator> __jakt_var_84; {
-TRY((((*this).error(Jakt::DeprecatedString("‘&&’ is not allowed, use ‘and’ instead"sv),span))));
-__jakt_var_84 =  parser::BinaryOperator { typename parser::BinaryOperator::LogicalAnd() } ; goto __jakt_label_80;
-
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_80:; __jakt_var_84.release_value(); }));
-};/*case end*/
-case 40: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseOr() } );
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 42: {
-return JaktInternal::ExplicitValue(({ Optional<parser::BinaryOperator> __jakt_var_85; {
-TRY((((*this).error(Jakt::DeprecatedString("‘||’ is not allowed, use ‘or’ instead"sv),span))));
-__jakt_var_85 =  parser::BinaryOperator { typename parser::BinaryOperator::LogicalOr() } ; goto __jakt_label_81;
-
+case 32: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShiftEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_81:; __jakt_var_85.release_value(); }));
-};/*case end*/
-case 43: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseXor() } );
-};/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseLeftShift() } );
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 33: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseRightShift() } );
-};/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::ArithmeticLeftShift() } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShift>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 34: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::ArithmeticRightShift() } );
-};/*case end*/
-case 16: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Assign() } );
-};/*case end*/
-case 32: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseLeftShiftAssign() } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightArithmeticShift>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 35: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseRightShiftAssign() } );
-};/*case end*/
-case 38: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseAndAssign() } );
-};/*case end*/
-case 41: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseOrAssign() } );
-};/*case end*/
-case 44: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseXorAssign() } );
-};/*case end*/
-case 17: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::AddAssign() } );
-};/*case end*/
-case 19: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::SubtractAssign() } );
-};/*case end*/
-case 21: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::MultiplyAssign() } );
-};/*case end*/
-case 22: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::DivideAssign() } );
-};/*case end*/
-case 23: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::ModuloAssign() } );
-};/*case end*/
-case 51: {
-return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::NoneCoalescingAssign() } );
-};/*case end*/
-default: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShiftEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-((((*this).index)++));
-if (((!(allow_assignments)) && ((op).is_assignment()))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment is not allowed in this position"sv),span))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Operator>(op,span))));
-}
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Operator>(op,span))));
+case 36: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Asterisk>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 37: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Ampersand>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parser::Parser::parse_for_statement() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 38: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const start_span = ((((*this).current())).span());
-((((*this).index)++));
-DeprecatedString iterator_name = Jakt::DeprecatedString(""sv);
-JaktInternal::DynamicArray<parser::ParsedVarDecl> destructured_var_decls = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
-utility::Span name_span = ((((*this).current())).span());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 39: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandAmpersand>();
+utility::Span const& span = __jakt_match_value.value;
 {
-(iterator_name = name);
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 7: {
+case 40: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Pipe>();
+utility::Span const& span = __jakt_match_value.value;
 {
-parser::ParsedVarDeclTuple const destructured_assignment = TRY((((*this).parse_destructuring_assignment(false))));
-(destructured_var_decls = ((destructured_assignment).var_decls));
-DeprecatedString tuple_var_name = Jakt::DeprecatedString(""sv);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 41: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipeEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedVarDecl> _magic = ((destructured_var_decls).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedVarDecl> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-parser::ParsedVarDecl var = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 42: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipePipe>();
+utility::Span const& span = __jakt_match_value.value;
 {
-(tuple_var_name += ((var).name));
-(tuple_var_name += Jakt::DeprecatedString("__"sv));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 43: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Caret>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 44: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::CaretEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-(name_span = ((destructured_assignment).span));
-(iterator_name = tuple_var_name);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 45: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dollar>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 46: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected iterator name or destructuring pattern"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Garbage>(TRY((parser::merge_spans(start_span,((((*this).current())).span()))))))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-if (((((*this).current())).index() == 79 /* In */)){
-((((*this).index)++));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘in’"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Garbage>(TRY((parser::merge_spans(start_span,((((*this).current())).span()))))))));
-}
-
-bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
-(((*this).can_have_trailing_closure) = false);
-NonnullRefPtr<typename parser::ParsedExpression> const range = TRY((((*this).parse_expression(false,false))));
-(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
-bool is_destructuring = false;
-parser::ParsedBlock block = TRY((((*this).parse_block())));
-if ((((destructured_var_decls).size()) > static_cast<size_t>(0ULL))){
-(is_destructuring = true);
-DeprecatedString tuple_var_name = Jakt::DeprecatedString("jakt__"sv);
-(tuple_var_name += iterator_name);
-parser::ParsedVarDecl tuple_var_decl = parser::ParsedVarDecl(tuple_var_name,TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),false,JaktInternal::OptionalNone(),((((*this).current())).span()));
-NonnullRefPtr<typename parser::ParsedExpression> const init = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(iterator_name,TRY((parser::merge_spans(start_span,((((*this).previous())).span())))))));
-NonnullRefPtr<typename parser::ParsedStatement> const var_decl = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(tuple_var_decl,init,TRY((parser::merge_spans(start_span,((((*this).previous())).span())))))));
-NonnullRefPtr<typename parser::ParsedStatement> const destructured_vars_stmt = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::DestructuringAssignment>(destructured_var_decls,var_decl,TRY((parser::merge_spans(start_span,((((*this).previous())).span())))))));
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> block_stmts = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({}))));
-TRY((((block_stmts).push(destructured_vars_stmt))));
-TRY((((block_stmts).push_values(((((block).stmts)))))));
-(((block).stmts) = block_stmts);
-}
-return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::For>(iterator_name,name_span,is_destructuring,range,block,TRY((parser::merge_spans(start_span,((((*this).previous())).span()))))))));
+case 47: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlash>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 48: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ExclamationPoint>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedParameter>> parser::Parser::parse_function_parameters() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 49: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMark>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((((*this).current())).index() == 7 /* LParen */)){
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '('"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 50: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMark>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-((*this).skip_newlines());
-JaktInternal::DynamicArray<parser::ParsedParameter> params = (TRY((DynamicArray<parser::ParsedParameter>::create_with({}))));
-bool current_param_requires_label = true;
-bool current_param_is_mutable = false;
-bool error = false;
-bool parameter_complete = false;
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::ParsedParameter>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 8: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 51: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMarkEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 52: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comma>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((!(parameter_complete)) && (!(error)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected parameter"sv),((((*this).current())).span())))));
-(error = true);
-}
-((((*this).index)++));
-(current_param_requires_label = true);
-(current_param_is_mutable = false);
-(parameter_complete = false);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 53: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((!(parameter_complete)) && (!(error)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected parameter"sv),((((*this).current())).span())))));
-(error = true);
-}
-((((*this).index)++));
-(current_param_requires_label = true);
-(current_param_is_mutable = false);
-(parameter_complete = false);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 60: {
+case 54: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DotDot>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((parameter_complete && (!(error)))){
-TRY((((*this).error(Jakt::DeprecatedString("‘anon’ must appear at start of parameter declaration, not the end"sv),((((*this).current())).span())))));
-(error = true);
-}
-if ((current_param_is_mutable && (!(error)))){
-TRY((((*this).error(Jakt::DeprecatedString("‘anon’ must appear before ‘mut’"sv),((((*this).current())).span())))));
-(error = true);
-}
-if (((!(current_param_requires_label)) && (!(error)))){
-TRY((((*this).error(Jakt::DeprecatedString("‘anon’ cannot appear multiple times in one parameter declaration"sv),((((*this).current())).span())))));
-(error = true);
-}
-((((*this).index)++));
-(current_param_requires_label = false);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 84: {
+case 57: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::FatArrow>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((parameter_complete && (!(error)))){
-TRY((((*this).error(Jakt::DeprecatedString("‘mut’ must appear at start of parameter declaration, not the end"sv),((((*this).current())).span())))));
-(error = true);
-}
-if ((current_param_is_mutable && (!(error)))){
-TRY((((*this).error(Jakt::DeprecatedString("‘mut’ cannot appear multiple times in one parameter declaration"sv),((((*this).current())).span())))));
-(error = true);
-}
-((((*this).index)++));
-(current_param_is_mutable = true);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 97: {
+case 58: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Arrow>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((params).push(parser::ParsedParameter(false,parser::ParsedVariable(Jakt::DeprecatedString("this"sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),current_param_is_mutable,((((*this).current())).span())),JaktInternal::OptionalNone(),((((*this).current())).span()))))));
-((((*this).index)++));
-(parameter_complete = true);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+case 59: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::And>();
+utility::Span const& span = __jakt_match_value.value;
 {
-parser::ParsedVarDecl const var_decl = TRY((((*this).parse_variable_declaration(current_param_is_mutable))));
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_argument = JaktInternal::OptionalNone();
-if (((((*this).current())).index() == 16 /* Equal */)){
-((((*this).index)++));
-(default_argument = TRY((((*this).parse_expression(false,true)))));
-}
-TRY((((params).push(parser::ParsedParameter(current_param_requires_label,parser::ParsedVariable(((var_decl).name),((var_decl).parsed_type),((var_decl).is_mutable),((((*this).previous())).span())),default_argument,((((*this).previous())).span()))))));
-(parameter_complete = true);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 60: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Anon>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((!(error))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected parameter"sv),((((*this).current())).span())))));
-(error = true);
-}
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-return (params);
-}
-}
-
-ErrorOr<JaktInternal::Optional<parser::ParsedCall>> parser::Parser::parse_call() {
-{
-parser::ParsedCall call = parser::ParsedCall((TRY((DynamicArray<DeprecatedString>::create_with({})))),Jakt::DeprecatedString(""sv),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({})))));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-(((call).name) = name);
-((((*this).index)++));
-size_t const index_reset = ((*this).index);
-if (((((*this).current())).index() == 28 /* LessThan */)){
-((((*this).index)++));
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> inner_types = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<parser::ParsedCall>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 26: {
+case 61: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::As>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 33: {
+case 62: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Boxed>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).inject_token( lexer::Token { typename lexer::Token::GreaterThan(((((*this).current())).span())) } ))));
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 63: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Break>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 64: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Catch>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 65: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Class>();
+utility::Span const& span = __jakt_match_value.value;
 {
-size_t const index_before = ((*this).index);
-NonnullRefPtr<typename parser::ParsedType> const inner_type = TRY((((*this).parse_typename())));
-if ((index_before == ((*this).index))){
-(((*this).index) = index_reset);
-return JaktInternal::LoopBreak{};
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-TRY((((inner_types).push(inner_type))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 66: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Continue>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-(((call).type_args) = inner_types);
-}
-if (((((*this).current())).index() == 7 /* LParen */)){
-((((*this).index)++));
-}
-else {
-(((*this).index) = index_reset);
-TRY((((*this).error(Jakt::DeprecatedString("Expected '('"sv),((((*this).current())).span())))));
-return (JaktInternal::OptionalNone());
+case 67: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Cpp>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<parser::ParsedCall>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 8: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 68: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Defer>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 69: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Destructor>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 70: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Else>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 71: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Enum>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const label_span = ((((*this).current())).span());
-DeprecatedString const label = TRY((((*this).parse_argument_label())));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-TRY((((((call).args)).push((Tuple{label, label_span, expr})))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
+case 72: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Extern>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-if ((((*this).can_have_trailing_closure) && ((((*this).current())).index() == 9 /* LCurly */))){
-utility::Span const start = ((((*this).current())).span());
-parser::ParsedBlock const block = TRY((((*this).parse_block())));
-utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
-JaktInternal::DynamicArray<parser::ParsedCapture> const captures = (TRY((DynamicArray<parser::ParsedCapture>::create_with({ parser::ParsedCapture { typename parser::ParsedCapture::AllByReference(Jakt::DeprecatedString(""sv),((*this).empty_span())) } }))));
-NonnullRefPtr<typename parser::ParsedExpression> const trailing_closure = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Function>(captures,(TRY((DynamicArray<parser::ParsedParameter>::create_with({})))),false,false,TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),block,span)));
-NonnullRefPtr<typename parser::ParsedExpression> const reference_to_closure = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(trailing_closure, parser::UnaryOperator { typename parser::UnaryOperator::Reference() } ,span)));
-TRY((((((call).args)).push((Tuple{Jakt::DeprecatedString(""sv), ((*this).empty_span()), reference_to_closure})))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 73: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-return (call);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 74: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::For>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected function call"sv),((((*this).current())).span())))));
-return (call);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 76: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comptime>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 77: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::If>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 78: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Import>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_array_or_dictionary_literal() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 79: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::In>();
+utility::Span const& span = __jakt_match_value.value;
 {
-bool is_dictionary = false;
-utility::Span const start = ((((*this).current())).span());
-if ((!(((((*this).current())).index() == 11 /* LSquare */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘[’"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-((((*this).index)++));
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> fill_size_expr = JaktInternal::OptionalNone();
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> output = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>>::create_with({}))));
-JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> dict_output = (TRY((DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({}))));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 12: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 80: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Is>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 81: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Let>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 55: {
+case 82: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Loop>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
+case 83: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Match>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((((output).size()) == static_cast<size_t>(1ULL))){
-((((*this).index)++));
-(fill_size_expr = TRY((((*this).parse_expression(false,false)))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Can't fill an Array with more than one expression"sv),((((*this).current())).span())))));
-((((*this).index)++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 84: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Mut>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 85: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Namespace>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 5: {
+case 86: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((((*this).index)++));
-if (((dict_output).is_empty())){
-if (((((*this).current())).index() == 12 /* RSquare */)){
-((((*this).index)++));
-(is_dictionary = true);
-return JaktInternal::LoopBreak{};
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]’"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 87: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Or>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 88: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Override>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Missing key in dictionary literal"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 89: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 90: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 91: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Raw>();
+utility::Span const& span = __jakt_match_value.value;
 {
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-if (((expr)->index() == 29 /* Garbage */)){
-return JaktInternal::LoopBreak{};
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-if (((((*this).current())).index() == 5 /* Colon */)){
-if ((!(((output).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Mixing dictionary and array values"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 92: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-(is_dictionary = true);
-((((*this).index)++));
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Key missing value in dictionary"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 93: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Return>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-NonnullRefPtr<typename parser::ParsedExpression> const value = TRY((((*this).parse_expression(false,false))));
-TRY((((dict_output).push((Tuple{expr, value})))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 94: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else if ((!(is_dictionary))){
-TRY((((output).push(expr))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 95: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 96: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Struct>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
+case 97: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-size_t const end = (JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL)));
-if (((end >= ((((*this).tokens)).size())) || (!(((((((*this).tokens))[end])).index() == 12 /* RSquare */))))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]’ to close the array"sv),((((((*this).tokens))[end])).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 98: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throw>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-if (is_dictionary){
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::JaktDictionary>(dict_output,TRY((parser::merge_spans(start,((((((*this).tokens))[end])).span()))))))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 99: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throws>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::JaktArray>(output,fill_size_expr,TRY((parser::merge_spans(start,((((((*this).tokens))[end])).span()))))))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 100: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 101: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 102: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Unsafe>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_operand() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 103: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Virtual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-((*this).skip_newlines());
-utility::Span const start = ((((*this).current())).span());
-((*this).skip_newlines());
-NonnullRefPtr<typename parser::ParsedExpression> expr = TRY((((*this).parse_operand_base())));
-return (TRY((((*this).parse_operand_postfix_operator(start,expr)))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 104: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Weak>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-ErrorOr<parser::ParsedNamespace> parser::Parser::parse(NonnullRefPtr<compiler::Compiler> const compiler,JaktInternal::DynamicArray<lexer::Token> const tokens) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 105: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::While>();
+utility::Span const& span = __jakt_match_value.value;
 {
-parser::Parser parser = parser::Parser(static_cast<size_t>(0ULL),tokens,compiler,true);
-return (TRY((((parser).parse_namespace()))));
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 106: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Yield>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
-ErrorOr<parser::ParsedExternImport> parser::Parser::parse_extern_import(parser::ParsedNamespace& parent) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 107: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Guard>();
+utility::Span const& span = __jakt_match_value.value;
 {
-parser::ParsedExternImport parsed_import = parser::ParsedExternImport(false,parser::ParsedNamespace(JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedFunction>::create_with({})))),(TRY((DynamicArray<parser::ParsedRecord>::create_with({})))),(TRY((DynamicArray<parser::ParsedTrait>::create_with({})))),(TRY((DynamicArray<parser::ParsedExternalTraitImplementation>::create_with({})))),(TRY((DynamicArray<parser::ParsedNamespace>::create_with({})))),(TRY((DynamicArray<parser::ParsedAlias>::create_with({})))),(TRY((DynamicArray<parser::ParsedModuleImport>::create_with({})))),(TRY((DynamicArray<parser::ParsedExternImport>::create_with({})))),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),(TRY((DynamicArray<parser::IncludeAction>::create_with({}))))),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
-((((*this).index)++));
-if (((name == Jakt::DeprecatedString("c"sv)) || (name == Jakt::DeprecatedString("C"sv)))){
-(((parsed_import).is_c) = true);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected 'c' or path after `import extern`"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 108: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Implements>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 109: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Requires>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-DeprecatedString const import_path = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<parser::ParsedExternImport>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_86; {
-((((*this).index)++));
-__jakt_var_86 = quote; goto __jakt_label_82;
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 110: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Trait>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_82:; __jakt_var_86.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_87; {
-TRY((((*this).error(Jakt::DeprecatedString("Expected path after `import extern`"sv),((((*this).current())).span())))));
-__jakt_var_87 = Jakt::DeprecatedString(""sv); goto __jakt_label_83;
-
+case 111: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Garbage>();utility::Span const& span = __jakt_match_value.span;
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Expected 'function' keyword inside trait definition"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Inside '{}' trait's definition only function declarations can appear"sv),((parsed_trait).name)))),((parsed_trait).name_span)))));
+return (parsed_trait);
 }
-__jakt_label_83:; __jakt_var_87.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-if (((((*this).current())).index() == 61 /* As */)){
-((((*this).index)++));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
-((((*this).index)++));
-(((((parsed_import).assigned_namespace)).name) = name);
-(((((parsed_import).assigned_namespace)).name_span) = span);
+}
+return (parsed_trait);
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected name after 'as' keyword to name the extern import"sv),((((*this).current())).span())))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected '{' to enter the body of the trait"sv),((((*this).current())).span())))));
+return (parsed_trait);
 }
 
 }
-if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected '{' to start namespace for the extern import"sv),((((*this).current())).span())))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),((((*this).current())).span())))));
+return (parsed_trait);
 }
-((((*this).index)++));
-(((parsed_import).assigned_namespace) = TRY((((*this).parse_namespace()))));
-(((((parsed_import).assigned_namespace)).import_path_if_extern) = static_cast<JaktInternal::Optional<DeprecatedString>>(import_path));
-(((((parsed_import).assigned_namespace)).generating_import_extern_before_include) = ((parsed_import).before_include));
-(((((parsed_import).assigned_namespace)).generating_import_extern_after_include) = ((parsed_import).after_include));
-if (((((*this).current())).index() == 10 /* RCurly */)){
-((((*this).index)++));
+
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected '}' to end namespace for the extern import"sv),((((*this).current())).span())))));
 }
 
-for (;;){
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<parser::ParsedExternImport>>{
-auto __jakt_enum_value = (name);
-if (__jakt_enum_value == Jakt::DeprecatedString("before_include"sv)) {
+ErrorOr<parser::Visibility> parser::Parser::parse_restricted_visibility_modifier() {
 {
+utility::Span restricted_span = ((((*this).current())).span());
+((((*this).index)++));
+if (((((*this).current())).index() == 7 /* LParen */)){
 ((((*this).index)++));
-JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>> const actions = TRY((((*this).parse_include_action())));
-if (((actions).has_value())){
-TRY((((((parsed_import).before_include)).push_values((((actions.value())))))));
-}
 }
-return JaktInternal::ExplicitValue<void>();
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘(’"sv),((((*this).current())).span())))));
+return ( parser::Visibility { typename parser::Visibility::Restricted((TRY((DynamicArray<parser::VisibilityRestriction>::create_with({})))),restricted_span) } );
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("after_include"sv)) {
+
+JaktInternal::DynamicArray<parser::VisibilityRestriction> whitelist = (TRY((DynamicArray<parser::VisibilityRestriction>::create_with({}))));
+bool expect_comma = false;
+while ((((*this).index) < ((((*this).tokens)).size()))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::Visibility>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 8: {
 {
-((((*this).index)++));
-JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>> const actions = TRY((((*this).parse_include_action())));
-if (((actions).has_value())){
-TRY((((((parsed_import).after_include)).push_values((((actions.value())))))));
-}
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 52: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comma>();
+utility::Span const& span = __jakt_match_value.value;
+{
+if (expect_comma){
+(expect_comma = false);
 }
 else {
-{
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Unexpected comma"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
+
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
-}()))
-;
+};/*case end*/
+default: {
+{
+if (expect_comma){
+TRY((((*this).error(Jakt::DeprecatedString("Expected comma"sv),((((*this).current())).span())))));
+}
+((*this).skip_newlines());
+JaktInternal::DynamicArray<DeprecatedString> names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+for (;;){
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+TRY((((names).push(name))));
+((((*this).index)++));
+if (((((*this).current())).index() == 6 /* ColonColon */)){
+((((*this).index)++));
 }
 else {
 break;
 }
 
 }
-TRY((((((parent))).add_child_namespace(((parsed_import).assigned_namespace)))));
-return (parsed_import);
-}
+else {
+break;
 }
 
-ErrorOr<parser::ParsedModuleImport> parser::Parser::parse_module_import() {
-{
-parser::ParsedModuleImport parsed_import = parser::ParsedModuleImport( parser::ImportName { typename parser::ImportName::Literal(Jakt::DeprecatedString(""sv),((*this).empty_span())) } ,JaktInternal::OptionalNone(), parser::ImportList { typename parser::ImportList::List((TRY((DynamicArray<parser::ImportName>::create_with({}))))) } );
-(((parsed_import).module_name) = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ImportName, ErrorOr<parser::ParsedModuleImport>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ImportName, ErrorOr<parser::ParsedModuleImport>>{
-auto&& __jakt_match_variant = ((*this).peek(static_cast<size_t>(1ULL)));
-switch(__jakt_match_variant.index()) {
-case 7: {
-return JaktInternal::ExplicitValue(({ Optional<parser::ImportName> __jakt_var_88; {
-bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
-(((*this).can_have_trailing_closure) = false);
-NonnullRefPtr<typename parser::ParsedExpression> const expression = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>((TRY((((*this).parse_call()))).value()),span)));
-(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
-((((*this).index)--));
-__jakt_var_88 =  parser::ImportName { typename parser::ImportName::Comptime(expression) } ; goto __jakt_label_84;
+}
+if (((names).is_empty())){
+TRY((((*this).error(Jakt::DeprecatedString("Expected identifier"sv),((((*this).current())).span())))));
+}
+else {
+DeprecatedString const name = (((names).pop()).value());
+TRY((((whitelist).push(parser::VisibilityRestriction(names,name)))));
+}
 
+(expect_comma = true);
 }
-__jakt_label_84:; __jakt_var_88.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue( parser::ImportName { typename parser::ImportName::Literal(name,span) } );
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-default: {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected module name"sv),((((*this).current())).span())))));
-return (parsed_import);
+));
 }
-};/*case end*/
-}/*switch end*/
-}()
-)));
+(((restricted_span).end) = ((((((*this).current())).span())).end));
+if (((whitelist).is_empty())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Restriction list cannot be empty"sv),restricted_span,Jakt::DeprecatedString("Did you mean to use ‘private’ instead of ‘restricted’?"sv),restricted_span))));
+}
+if (((((*this).current())).index() == 8 /* RParen */)){
 ((((*this).index)++));
-if (((*this).eol())){
-return (parsed_import);
 }
-if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
-DeprecatedString module_name = ((((parsed_import).module_name)).literal_name());
-utility::Span module_span = ((((parsed_import).module_name)).span());
-while (((((*this).current())).index() == 6 /* ColonColon */)){
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘)’"sv),((((*this).current())).span())))));
+}
+
+return ( parser::Visibility { typename parser::Visibility::Restricted(whitelist,restricted_span) } );
+}
+}
+
+ErrorOr<parser::ParsedVarDeclTuple> parser::Parser::parse_destructuring_assignment(bool const is_mutable) {
+{
+utility::Span const start = ((((*this).current())).span());
 ((((*this).index)++));
-(module_name += Jakt::DeprecatedString("::"sv));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedModuleImport>>{
+JaktInternal::DynamicArray<parser::ParsedVarDecl> var_declarations = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
+for (;;){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedVarDeclTuple>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
 case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
 {
-(module_name += name);
-(module_span = TRY((parser::merge_spans(module_span,span))));
-((((*this).index)++));
+TRY((((var_declarations).push(TRY((((*this).parse_variable_declaration(is_mutable))))))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 61: {
+case 52: {
 {
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
+case 8: {
 {
+((((*this).index)++));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected module name fragment"sv),((((*this).current())).span())))));
-return (parsed_import);
+TRY((((*this).error(Jakt::DeprecatedString("Expected close of destructuring assignment block"sv),((((*this).current())).span())))));
+(var_declarations = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({})))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
@@ -7258,582 +7040,551 @@ return JaktInternal::ExplicitValue<void>();
 }()
 ));
 }
-(((parsed_import).module_name) =  parser::ImportName { typename parser::ImportName::Literal(module_name,module_span) } );
-}
-if (((((*this).current())).index() == 61 /* As */)){
-((((*this).index)++));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
-((((*this).index)++));
-(((parsed_import).alias_name) =  parser::ImportName { typename parser::ImportName::Literal(name,span) } );
+return (parser::ParsedVarDeclTuple(var_declarations,TRY((parser::merge_spans(start,((((*this).previous())).span()))))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected name"sv),((((*this).current())).span())))));
-((((*this).index)++));
 }
 
-}
-if (((*this).eol())){
-return (parsed_import);
-}
-if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected '{'"sv),((((*this).current())).span())))));
-}
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_operand_postfix_operator(utility::Span const start,NonnullRefPtr<typename parser::ParsedExpression> const expr) {
+{
+NonnullRefPtr<typename parser::ParsedExpression> result = expr;
+for (;;){
+(result = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 54: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_53; {
 ((((*this).index)++));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedModuleImport>>{
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> to = JaktInternal::OptionalNone();
+utility::Span span_end = ((((*this).current())).span());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+case 12: {
 {
-if (((((parsed_import).import_list)).index() == 0 /* List */)){
-JaktInternal::DynamicArray<parser::ImportName> const names = ((((parsed_import).import_list)).get<parser::ImportList::List>()).value;
-JaktInternal::DynamicArray<parser::ImportName> mutable_names = names;
-TRY((((mutable_names).push( parser::ImportName { typename parser::ImportName::Literal(name,span) } ))));
-}
-else {
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Already importing everything from '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span()),Jakt::DeprecatedString("Remove the '*' to import specific names"sv),((((*this).current())).span())))));
-}
-
-((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 36: {
+case 55: {
 {
-if (((((parsed_import).import_list)).index() == 0 /* List */)){
-JaktInternal::DynamicArray<parser::ImportName> const names = ((((parsed_import).import_list)).get<parser::ImportList::List>()).value;
-if (((names).is_empty())){
-(((parsed_import).import_list) =  parser::ImportList { typename parser::ImportList::All() } );
-}
-else {
-if (((((parsed_import).import_list)).index() == 1 /* All */)){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot repeat '*' in import list for '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span())))));
-}
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot mix '*' and specific names in import list for '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span())))));
-}
-
-}
-
-}
-else {
-if (((((parsed_import).import_list)).index() == 1 /* All */)){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot repeat '*' in import list for '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span())))));
-}
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot mix '*' and specific names in import list for '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span())))));
-}
-
-}
-
-((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 52: {
 {
-((((*this).index)++));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 55: {
-{
-((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 10: {
+case 8: {
 {
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected import symbol"sv),((((*this).current())).span())))));
-((((*this).index)++));
+(to = TRY((((*this).parse_operand()))));
+(span_end = (((to.value()))->span()));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-}
-return (parsed_import);
-}
-}
+__jakt_var_53 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Range>(result,to,TRY((parser::merge_spans(start,span_end)))))); goto __jakt_label_50;
 
-ErrorOr<parser::ParsedNamespace> parser::Parser::parse_namespace() {
-{
-parser::ParsedNamespace parsed_namespace = parser::ParsedNamespace(JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedFunction>::create_with({})))),(TRY((DynamicArray<parser::ParsedRecord>::create_with({})))),(TRY((DynamicArray<parser::ParsedTrait>::create_with({})))),(TRY((DynamicArray<parser::ParsedExternalTraitImplementation>::create_with({})))),(TRY((DynamicArray<parser::ParsedNamespace>::create_with({})))),(TRY((DynamicArray<parser::ParsedAlias>::create_with({})))),(TRY((DynamicArray<parser::ParsedModuleImport>::create_with({})))),(TRY((DynamicArray<parser::ParsedExternImport>::create_with({})))),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))));
-JaktInternal::DynamicArray<parser::ParsedAttribute> active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({}))));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedNamespace>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 110: {
-{
-if ((!(((active_attributes).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to trait declarations"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
 }
+__jakt_label_50:; __jakt_var_53.release_value(); }));
+};/*case end*/
+case 48: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_54; {
 ((((*this).index)++));
-TRY((((((parsed_namespace).traits)).push(TRY((((*this).parse_trait())))))));
+__jakt_var_54 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::ForcedUnwrap>(result,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_51;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_51:; __jakt_var_54.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<parser::ParsedNamespace>>{
-auto __jakt_enum_value = (name);
-if (__jakt_enum_value == Jakt::DeprecatedString("type"sv)) {
-{
-if ((!(((active_attributes).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to external trait declarations"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-}
+case 18: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_55; {
 ((((*this).index)++));
-TRY((((((parsed_namespace).external_trait_implementations)).push(TRY((((*this).parse_external_trait_implementation())))))));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("use"sv)) {
-{
-if ((!(((active_attributes).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to use declarations"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+__jakt_var_55 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::PostIncrement() } ,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_52;
+
 }
+__jakt_label_52:; __jakt_var_55.release_value(); }));
+};/*case end*/
+case 20: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_56; {
 ((((*this).index)++));
-TRY((((((parsed_namespace).aliases)).push(TRY((((*this).parse_using())))))));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((*this).error(Jakt::DeprecatedString("Unexpected token (expected keyword)"sv),((((*this).current())).span())))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
+__jakt_var_56 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::PostDecrement() } ,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_53;
+
 }
-return JaktInternal::ExplicitValue<void>();
-}()))
-), JaktInternal::ExplicitValue<void>();
+__jakt_label_53:; __jakt_var_56.release_value(); }));
 };/*case end*/
-case 78: {
-{
-if ((!(((active_attributes).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to imports"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-}
+case 61: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_57; {
 ((((*this).index)++));
-TRY((((*this).parse_import(((parsed_namespace))))));
+utility::Span const cast_span = TRY((parser::merge_spans(((((*this).previous())).span()),((((*this).current())).span()))));
+parser::TypeCast const cast = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::TypeCast, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 48: {
+return JaktInternal::ExplicitValue(({ Optional<parser::TypeCast> __jakt_var_58; {
+((((*this).index)++));
+__jakt_var_58 =  parser::TypeCast { typename parser::TypeCast::Infallible(TRY((((*this).parse_typename())))) } ; goto __jakt_label_55;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_55:; __jakt_var_58.release_value(); }));
 };/*case end*/
-case 11: {
-{
-if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 11 /* LSquare */)){
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
-TRY((((*this).parse_attribute_list(((active_attributes))))));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Unexpected token (expected ‘[[’)"sv),((((*this).current())).span())))));
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
-}
+case 49: {
+return JaktInternal::ExplicitValue(({ Optional<parser::TypeCast> __jakt_var_59; {
+((((*this).index)++));
+__jakt_var_59 =  parser::TypeCast { typename parser::TypeCast::Fallible(TRY((((*this).parse_typename())))) } ; goto __jakt_label_56;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_56:; __jakt_var_59.release_value(); }));
 };/*case end*/
-case 75: {
-{
-parser::ParsedFunction parsed_function = TRY((((*this).parse_function( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } , parser::Visibility { typename parser::Visibility::Public() } ,((((*this).current())).index() == 76 /* Comptime */),false,false))));
-TRY((((*this).apply_attributes(((parsed_function)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).functions)).push(parsed_function))));
+default: {
+return JaktInternal::ExplicitValue(({ Optional<parser::TypeCast> __jakt_var_60; {
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Invalid cast syntax"sv),cast_span,Jakt::DeprecatedString("Use `as!` for an infallible cast, or `as?` for a fallible cast"sv),((((*this).previous())).span())))));
+__jakt_var_60 =  parser::TypeCast { typename parser::TypeCast::Fallible(TRY((((*this).parse_typename())))) } ; goto __jakt_label_57;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_57:; __jakt_var_60.release_value(); }));
 };/*case end*/
-case 76: {
-{
-parser::ParsedFunction parsed_function = TRY((((*this).parse_function( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } , parser::Visibility { typename parser::Visibility::Public() } ,((((*this).current())).index() == 76 /* Comptime */),false,false))));
-TRY((((*this).apply_attributes(((parsed_function)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).functions)).push(parsed_function))));
+}/*switch end*/
+}()
+));
+utility::Span const span = TRY((parser::merge_spans(start,TRY((parser::merge_spans(cast_span,((((*this).current())).span())))))));
+__jakt_var_57 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::TypeCast(cast) } ,span))); goto __jakt_label_54;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_54:; __jakt_var_57.release_value(); }));
 };/*case end*/
-case 96: {
-{
-parser::ParsedRecord parsed_record = TRY((((*this).parse_record( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ))));
-TRY((((*this).apply_attributes(((parsed_record)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).records)).push(parsed_record))));
+case 80: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_61; {
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedType> const parsed_type = TRY((((*this).parse_typename())));
+utility::Span const span = TRY((parser::merge_spans(start,((((*this).current())).span()))));
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> bindings = (TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({}))));
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> unary_operator_is = JaktInternal::OptionalNone();
+if ((((((*this).current())).index() == 7 /* LParen */) && (((parsed_type)->index() == 1 /* NamespacedName */) || ((parsed_type)->index() == 0 /* Name */)))){
+(bindings = TRY((((*this).parse_variant_arguments()))));
+(unary_operator_is = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::IsEnumVariant(parsed_type,bindings) } ,span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 65: {
-{
-parser::ParsedRecord parsed_record = TRY((((*this).parse_record( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ))));
-TRY((((*this).apply_attributes(((parsed_record)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).records)).push(parsed_record))));
+else {
+(unary_operator_is = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(result, parser::UnaryOperator { typename parser::UnaryOperator::Is(parsed_type) } ,span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 71: {
-{
-parser::ParsedRecord parsed_record = TRY((((*this).parse_record( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ))));
-TRY((((*this).apply_attributes(((parsed_record)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).records)).push(parsed_record))));
+
+__jakt_var_61 = (unary_operator_is.value()); goto __jakt_label_58;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_58:; __jakt_var_61.release_value(); }));
 };/*case end*/
-case 62: {
-{
-parser::ParsedRecord parsed_record = TRY((((*this).parse_record( parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ))));
-TRY((((*this).apply_attributes(((parsed_record)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).records)).push(parsed_record))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 6: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_postfix_colon_colon(start,result)))));
 };/*case end*/
-case 85: {
-{
-if ((!(((active_attributes).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot apply attributes to namespaces"sv),((((active_attributes)[static_cast<i64>(0LL)])).span)))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
+case 49: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_62; {
+bool const is_optional = ((((*this).current())).index() == 49 /* QuestionMark */);
+if (is_optional){
+((((*this).index)++));
+if ((!(((((*this).current())).index() == 53 /* Dot */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘.’ after ‘?’ for optional chaining access"sv),((((*this).current())).span())))));
+}
 }
 ((((*this).index)++));
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>> const name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>>, ErrorOr<parser::ParsedNamespace>>{
+__jakt_var_62 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();lexer::LiteralPrefix const& prefix = __jakt_match_value.prefix;
+DeprecatedString const& number = __jakt_match_value.number;
+lexer::LiteralSuffix const& suffix = __jakt_match_value.suffix;
 utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_89; {
-((((*this).index)++));
-__jakt_var_89 = static_cast<JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>>>((Tuple{name, span})); goto __jakt_label_85;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_63; {
+NonnullRefPtr<typename parser::ParsedExpression> const numeric_constant = TRY((((*this).parse_number(prefix,number,suffix,span))));
+__jakt_var_63 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto __jakt_enum_value = (((numeric_constant)->index() == 1 /* NumericConstant */));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_64; {
+parser::NumericConstant const val = ((numeric_constant)->get<parser::ParsedExpression::NumericConstant>()).val;
+size_t const num = ((val).to_usize());
+__jakt_var_64 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedTuple>(result,num,is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_61;
 
 }
-__jakt_label_85:; __jakt_var_89.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-}/*switch end*/
-}()
-));
-((*this).skip_newlines());
-if (((((*this).current())).index() == 9 /* LCurly */)){
-((((*this).index)++));
+__jakt_label_61:; __jakt_var_64.release_value(); }));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
-}
-
-parser::ParsedNamespace namespace_ = TRY((((*this).parse_namespace())));
-if (((((*this).current())).index() == 10 /* RCurly */)){
-((((*this).index)++));
+{
+TRY((((*this).error(Jakt::DeprecatedString("Invalid Numeric Constant"sv),span))));
+return (expr);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete namespace"sv),((((*this).previous())).span())))));
 }
+}()))
+; goto __jakt_label_60;
 
-if (((name).has_value())){
-(((namespace_).name) = (((name.value())).template get<0>()));
-(((namespace_).name_span) = (((name.value())).template get<1>()));
-}
-TRY((((parsed_namespace).add_child_namespace(namespace_))));
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_60:; __jakt_var_63.release_value(); }));
 };/*case end*/
-case 72: {
-{
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_65; {
 ((((*this).index)++));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedNamespace>>{
+__jakt_var_65 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 75: {
-{
-parser::ParsedFunction parsed_function = TRY((((*this).parse_function( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } , parser::Visibility { typename parser::Visibility::Public() } ,false,false,false))));
-TRY((((*this).apply_attributes(((parsed_function)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).functions)).push(parsed_function))));
+case 28: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_66; {
+size_t const original_index = ((*this).index);
+JaktInternal::DynamicArray<error::JaktError> const existing_errors = TRY((((((((((*this).compiler))->errors))[(JaktInternal::Range<i64>{static_cast<i64>(0LL),static_cast<i64>(9223372036854775807LL)})])).to_array())));
+((((*this).index)--));
+JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
+__jakt_var_66 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto __jakt_enum_value = (((call).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(result,(call.value()),is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 96: {
-{
-parser::ParsedRecord parsed_struct = TRY((((*this).parse_struct( parser::DefinitionLinkage { typename parser::DefinitionLinkage::External() } ))));
-TRY((((*this).apply_attributes(((parsed_struct)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).records)).push(parsed_struct))));
+else {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_67; {
+(((*this).index) = original_index);
+(((((*this).compiler))->errors) = existing_errors);
+__jakt_var_67 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedStruct>(result,name,is_optional,TRY((parser::merge_spans(start,((((*this).current())).span()))))))); goto __jakt_label_64;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_64:; __jakt_var_67.release_value(); }));
+}
+}()))
+; goto __jakt_label_63;
+
+}
+__jakt_label_63:; __jakt_var_66.release_value(); }));
 };/*case end*/
-case 65: {
-{
-parser::ParsedRecord parsed_class = TRY((((*this).parse_class( parser::DefinitionLinkage { typename parser::DefinitionLinkage::External() } ))));
-TRY((((*this).apply_attributes(((parsed_class)),((active_attributes))))));
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((((parsed_namespace).records)).push(parsed_class))));
+case 7: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_68; {
+((((*this).index)--));
+JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
+__jakt_var_68 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(result,(call.value()),is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_65;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_65:; __jakt_var_68.release_value(); }));
 };/*case end*/
 default: {
-{
-(active_attributes = (TRY((DynamicArray<parser::ParsedAttribute>::create_with({})))));
-TRY((((*this).error(Jakt::DeprecatedString("Unexpected keyword"sv),((((*this).current())).span())))));
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedStruct>(result,name,is_optional,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
 };/*case end*/
 }/*switch end*/
 }()
-));
+)); goto __jakt_label_62;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_62:; __jakt_var_65.release_value(); }));
 };/*case end*/
-case 55: {
-{
+case 11: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_69; {
 ((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const index = TRY((((*this).parse_expression(false,false))));
+if ((!(((((*this).current())).index() == 12 /* RSquare */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]’ to close the index"sv),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 10: {
-{
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
+__jakt_var_69 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::ComptimeIndex>(result,index,is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_66;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_66:; __jakt_var_69.release_value(); }));
 };/*case end*/
 default: {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Unexpected token (expected keyword)"sv),((((*this).current())).span())))));
-return JaktInternal::LoopBreak{};
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_70; {
+TRY((((*this).error(Jakt::DeprecatedString("Unsupported dot operation"sv),((((*this).current())).span())))));
+((((*this).index)++));
+__jakt_var_70 = result; goto __jakt_label_67;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_67:; __jakt_var_70.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
-));
+)); goto __jakt_label_59;
+
 }
-return (parsed_namespace);
+__jakt_label_59:; __jakt_var_62.release_value(); }));
+};/*case end*/
+case 53: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_71; {
+bool const is_optional = ((((*this).current())).index() == 49 /* QuestionMark */);
+if (is_optional){
+((((*this).index)++));
+if ((!(((((*this).current())).index() == 53 /* Dot */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘.’ after ‘?’ for optional chaining access"sv),((((*this).current())).span())))));
 }
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_ampersand() {
-{
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-if (((((*this).current())).index() == 91 /* Raw */)){
 ((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::RawAddress() } ,TRY((parser::merge_spans(start,((expr)->span()))))))));
+__jakt_var_71 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();lexer::LiteralPrefix const& prefix = __jakt_match_value.prefix;
+DeprecatedString const& number = __jakt_match_value.number;
+lexer::LiteralSuffix const& suffix = __jakt_match_value.suffix;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_72; {
+NonnullRefPtr<typename parser::ParsedExpression> const numeric_constant = TRY((((*this).parse_number(prefix,number,suffix,span))));
+__jakt_var_72 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto __jakt_enum_value = (((numeric_constant)->index() == 1 /* NumericConstant */));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_73; {
+parser::NumericConstant const val = ((numeric_constant)->get<parser::ParsedExpression::NumericConstant>()).val;
+size_t const num = ((val).to_usize());
+__jakt_var_73 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedTuple>(result,num,is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_70;
+
 }
-if (((((*this).current())).index() == 84 /* Mut */)){
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::MutableReference() } ,TRY((parser::merge_spans(start,((expr)->span()))))))));
+__jakt_label_70:; __jakt_var_73.release_value(); }));
 }
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::Reference() } ,TRY((parser::merge_spans(start,((expr)->span()))))))));
+else {
+{
+TRY((((*this).error(Jakt::DeprecatedString("Invalid Numeric Constant"sv),span))));
+return (expr);
 }
 }
+}()))
+; goto __jakt_label_69;
 
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchCase>> parser::Parser::parse_match_cases() {
-{
-JaktInternal::DynamicArray<parser::ParsedMatchCase> cases = (TRY((DynamicArray<parser::ParsedMatchCase>::create_with({}))));
-((*this).skip_newlines());
-if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
-return (cases);
 }
+__jakt_label_69:; __jakt_var_72.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_74; {
 ((((*this).index)++));
-((*this).skip_newlines());
-while (((!(((*this).eof()))) && (!(((((*this).current())).index() == 10 /* RCurly */))))){
-utility::Span const marker_span = ((((*this).current())).span());
-size_t const pattern_start_index = ((*this).index);
-JaktInternal::DynamicArray<parser::ParsedMatchPattern> const patterns = TRY((((*this).parse_match_patterns())));
-((*this).skip_newlines());
-if (((((*this).current())).index() == 57 /* FatArrow */)){
-((((*this).index)++));
+__jakt_var_74 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 28: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_75; {
+size_t const original_index = ((*this).index);
+JaktInternal::DynamicArray<error::JaktError> const existing_errors = TRY((((((((((*this).compiler))->errors))[(JaktInternal::Range<i64>{static_cast<i64>(0LL),static_cast<i64>(9223372036854775807LL)})])).to_array())));
+((((*this).index)--));
+JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
+__jakt_var_75 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto __jakt_enum_value = (((call).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(result,(call.value()),is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘=>’"sv),((((*this).current())).span())))));
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_76; {
+(((*this).index) = original_index);
+(((((*this).compiler))->errors) = existing_errors);
+__jakt_var_76 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedStruct>(result,name,is_optional,TRY((parser::merge_spans(start,((((*this).current())).span()))))))); goto __jakt_label_73;
+
+}
+__jakt_label_73:; __jakt_var_76.release_value(); }));
 }
+}()))
+; goto __jakt_label_72;
 
-((*this).skip_newlines());
-parser::ParsedMatchBody const body = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ParsedMatchBody, ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchCase>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 9: {
-return JaktInternal::ExplicitValue( parser::ParsedMatchBody { typename parser::ParsedMatchBody::Block(TRY((((*this).parse_block())))) } );
+}
+__jakt_label_72:; __jakt_var_75.release_value(); }));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_77; {
+((((*this).index)--));
+JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
+__jakt_var_77 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(result,(call.value()),is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_74;
+
+}
+__jakt_label_74:; __jakt_var_77.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue( parser::ParsedMatchBody { typename parser::ParsedMatchBody::Expression(TRY((((*this).parse_expression(false,true))))) } );
+return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedStruct>(result,name,is_optional,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
 };/*case end*/
 }/*switch end*/
 }()
-));
-{
-JaktInternal::ArrayIterator<parser::ParsedMatchPattern> _magic = ((patterns).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMatchPattern> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+)); goto __jakt_label_71;
+
 }
-parser::ParsedMatchPattern pattern = (_magic_value.value());
-{
-TRY((((cases).push(parser::ParsedMatchCase((TRY((DynamicArray<parser::ParsedMatchPattern>::create_with({pattern})))),marker_span,body)))));
+__jakt_label_71:; __jakt_var_74.release_value(); }));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_78; {
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const index = TRY((((*this).parse_expression(false,false))));
+if ((!(((((*this).current())).index() == 12 /* RSquare */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]’ to close the index"sv),((((*this).current())).span())))));
 }
+((((*this).index)++));
+__jakt_var_78 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::ComptimeIndex>(result,index,is_optional,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_75;
 
 }
+__jakt_label_75:; __jakt_var_78.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_79; {
+TRY((((*this).error(Jakt::DeprecatedString("Unsupported dot operation"sv),((((*this).current())).span())))));
+((((*this).index)++));
+__jakt_var_79 = result; goto __jakt_label_76;
+
 }
+__jakt_label_76:; __jakt_var_79.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)); goto __jakt_label_68;
 
-if ((((*this).index) == pattern_start_index)){
-break;
 }
-if ((((((*this).current())).index() == 55 /* Eol */) || ((((*this).current())).index() == 52 /* Comma */))){
+__jakt_label_68:; __jakt_var_71.release_value(); }));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_80; {
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const index_expr = TRY((((*this).parse_expression(false,false))));
+if (((((*this).current())).index() == 12 /* RSquare */)){
 ((((*this).index)++));
 }
-((*this).skip_newlines());
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ']'"sv),((((*this).current())).span())))));
 }
-((*this).skip_newlines());
-if ((!(((((*this).current())).index() == 10 /* RCurly */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘}’"sv),((((*this).current())).span())))));
+
+size_t const end = (JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL)));
+__jakt_var_80 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedExpression>(result,index_expr,TRY((parser::merge_spans(start,((((((*this).tokens))[end])).span()))))))); goto __jakt_label_77;
+
 }
-((((*this).index)++));
-return (cases);
+__jakt_label_77:; __jakt_var_80.release_value(); }));
+};/*case end*/
+default: {
+{
+return JaktInternal::LoopBreak{};
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
+}
+return (result);
 }
 }
 
-ErrorOr<JaktInternal::Optional<parser::NumericConstant>> parser::Parser::make_float_numeric_constant(f64 const number,lexer::LiteralSuffix const suffix,utility::Span const span) {
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_set_literal() {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<parser::NumericConstant>, ErrorOr<JaktInternal::Optional<parser::NumericConstant>>>{
-auto&& __jakt_match_variant = suffix;
+utility::Span const start = ((((*this).current())).span());
+if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘{’"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))));
+}
+((((*this).index)++));
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> output = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>>::create_with({}))));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
 case 10: {
-return JaktInternal::ExplicitValue( parser::NumericConstant { typename parser::NumericConstant::F32(parser::f64_to_f32(number)) } );
+{
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue( parser::NumericConstant { typename parser::NumericConstant::F64(number) } );
+case 52: {
+{
+((((*this).index)++));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 55: {
+{
+((((*this).index)++));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+{
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+if (((expr)->index() == 29 /* Garbage */)){
+return JaktInternal::LoopBreak{};
+}
+TRY((((output).push(expr))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
+));
+}
+size_t const end = (JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL)));
+if (((end >= ((((*this).tokens)).size())) || (!(((((((*this).tokens))[end])).index() == 10 /* RCurly */))))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘}’ to close the set"sv),((((((*this).tokens))[end])).span())))));
+}
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Set>(output,TRY((parser::merge_spans(start,((((((*this).tokens))[end])).span()))))))));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_postfix_colon_colon(utility::Span const start,NonnullRefPtr<typename parser::ParsedExpression> const expr) {
+ErrorOr<void> parser::Parser::parse_attribute_list(JaktInternal::DynamicArray<parser::ParsedAttribute>& active_attributes) {
 {
-((((*this).index)++));
-JaktInternal::DynamicArray<DeprecatedString> namespace_ = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-if (((expr)->index() == 9 /* Var */)){
-DeprecatedString const name = ((expr)->get<parser::ParsedExpression::Var>()).name;
-TRY((((namespace_).push(name))));
+while ((((!(((*this).eof()))) && (!(((((*this).current())).index() == 12 /* RSquare */)))) && (!(((((*this).peek(static_cast<size_t>(1ULL)))).index() == 12 /* RSquare */))))){
+JaktInternal::Optional<parser::ParsedAttribute> const attribute = TRY((((*this).parse_attribute())));
+if (((attribute).has_value())){
+TRY((((((active_attributes))).push((attribute.value())))));
+}
+}
+if ((((((*this).current())).index() == 12 /* RSquare */) && ((((*this).peek(static_cast<size_t>(1ULL)))).index() == 12 /* RSquare */))){
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected namespace"sv),((expr)->span())))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]]’"sv),((((*this).current())).span())))));
 }
 
-while ((!(((*this).eof())))){
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const current_name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-((((*this).index)++));
-if (((((*this).current())).index() == 7 /* LParen */)){
-((((*this).index)--));
-JaktInternal::Optional<parser::ParsedCall> call = TRY((((*this).parse_call())));
-((((call.value())).namespace_) = namespace_);
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>((call.value()),TRY((parser::merge_spans(((expr)->span()),((((*this).current())).span()))))))));
 }
-if (((((*this).current())).index() == 28 /* LessThan */)){
-((((*this).index)--));
-JaktInternal::Optional<parser::ParsedCall> const maybe_call = TRY((((*this).parse_call())));
-if (((maybe_call).has_value())){
-parser::ParsedCall call = (maybe_call.value());
-(((call).namespace_) = namespace_);
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>(call,TRY((parser::merge_spans(((expr)->span()),((((*this).current())).span()))))))));
-}
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))));
-}
-if (((((*this).current())).index() == 6 /* ColonColon */)){
-if (((((*this).previous())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).previous())).get<lexer::Token::Identifier>()).name;
-TRY((((namespace_).push(name))));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected namespace"sv),((expr)->span())))));
+return {};
 }
 
-((((*this).index)++));
-}
-else {
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::NamespacedVar>(current_name,namespace_,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
-}
+parser::Parser::Parser(size_t a_index, JaktInternal::DynamicArray<lexer::Token> a_tokens, NonnullRefPtr<compiler::Compiler> a_compiler, bool a_can_have_trailing_closure) :index(move(a_index)), tokens(move(a_tokens)), compiler(move(a_compiler)), can_have_trailing_closure(move(a_can_have_trailing_closure)){}
 
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_expression(bool const allow_assignments,bool const allow_newlines) {
+{
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> expr_stack = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>>::create_with({}))));
+i64 last_precedence = static_cast<i64>(1000000LL);
+NonnullRefPtr<typename parser::ParsedExpression> const lhs = TRY((((*this).parse_operand())));
+TRY((((expr_stack).push(lhs))));
+for (;;){
+if (allow_newlines){
+if ((((*this).eof()) || ((((*this).current())).index() == 9 /* LCurly */))){
+break;
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Unsupported static method call"sv),((((*this).current())).span())))));
-return (expr);
-}
-
+((*this).skip_newlines());
 }
-TRY((((*this).error(Jakt::DeprecatedString("Incomplete static method call"sv),((((*this).current())).span())))));
-return (expr);
+else {
+if (((*this).eol())){
+break;
 }
 }
 
-parser::Parser::Parser(size_t a_index, JaktInternal::DynamicArray<lexer::Token> a_tokens, NonnullRefPtr<compiler::Compiler> a_compiler, bool a_can_have_trailing_closure) :index(move(a_index)), tokens(move(a_tokens)), compiler(move(a_compiler)), can_have_trailing_closure(move(a_can_have_trailing_closure)){}
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parser::Parser::parse_if_statement() {
-{
-if ((!(((((*this).current())).index() == 77 /* If */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ‘if’ statement"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Garbage>(((((*this).current())).span())))));
+NonnullRefPtr<typename parser::ParsedExpression> const parsed_operator = TRY((((*this).parse_operator(allow_assignments))));
+if (((parsed_operator)->index() == 29 /* Garbage */)){
+break;
 }
-utility::Span const start_span = ((((*this).current())).span());
-((((*this).index)++));
-bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
-(((*this).can_have_trailing_closure) = false);
-NonnullRefPtr<typename parser::ParsedExpression> const condition = TRY((((*this).parse_expression(false,true))));
-(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
-parser::ParsedBlock const then_block = TRY((((*this).parse_block())));
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> else_statement = JaktInternal::OptionalNone();
-((*this).skip_newlines());
-if (((((*this).current())).index() == 70 /* Else */)){
-((((*this).index)++));
+i64 const precedence = ((parsed_operator)->precedence());
 ((*this).skip_newlines());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 77: {
-{
-(else_statement = TRY((((*this).parse_if_statement()))));
+NonnullRefPtr<typename parser::ParsedExpression> const rhs = TRY((((*this).parse_operand())));
+while (((precedence <= last_precedence) && (((expr_stack).size()) > static_cast<size_t>(1ULL)))){
+NonnullRefPtr<typename parser::ParsedExpression> const rhs = (((expr_stack).pop()).value());
+NonnullRefPtr<typename parser::ParsedExpression> const op = (((expr_stack).pop()).value());
+(last_precedence = ((op)->precedence()));
+if ((last_precedence < precedence)){
+TRY((((expr_stack).push(op))));
+TRY((((expr_stack).push(rhs))));
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 9: {
+NonnullRefPtr<typename parser::ParsedExpression> const lhs = (((expr_stack).pop()).value());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = *op;
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& op = __jakt_match_value.op;
+utility::Span const& span = __jakt_match_value.span;
 {
-parser::ParsedBlock const block = TRY((((*this).parse_block())));
-if (((then_block).equals(block))){
-TRY((((*this).error(Jakt::DeprecatedString("if and else have identical blocks"sv),((((*this).current())).span())))));
-}
-(else_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(block,TRY((parser::merge_spans(start_span,((((*this).previous())).span()))))))));
+utility::Span const new_span = TRY((parser::merge_spans(((lhs)->span()),((rhs)->span()))));
+TRY((((expr_stack).push(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::BinaryOp>(lhs,op,rhs,new_span)))))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("‘else’ missing ‘if’ or block"sv),((((*this).previous())).span())))));
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("operator is not an operator"sv)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
@@ -7841,498 +7592,367 @@ return JaktInternal::ExplicitValue<void>();
 }()
 ));
 }
-return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::If>(condition,then_block,else_statement,TRY((parser::merge_spans(start_span,((((*this).previous())).span()))))))));
+TRY((((expr_stack).push(parsed_operator))));
+TRY((((expr_stack).push(rhs))));
+(last_precedence = precedence);
 }
+while ((((expr_stack).size()) > static_cast<size_t>(1ULL))){
+NonnullRefPtr<typename parser::ParsedExpression> const rhs = (((expr_stack).pop()).value());
+NonnullRefPtr<typename parser::ParsedExpression> const parsed_operator = (((expr_stack).pop()).value());
+NonnullRefPtr<typename parser::ParsedExpression> const lhs = (((expr_stack).pop()).value());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = *parsed_operator;
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& op = __jakt_match_value.op;
+utility::Span const& span = __jakt_match_value.span;
+{
+utility::Span const new_span = TRY((parser::merge_spans(((lhs)->span()),((rhs)->span()))));
+TRY((((expr_stack).push(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::BinaryOp>(lhs,op,rhs,new_span)))))));
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_shorthand_set() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-utility::Span const start = ((((*this).current())).span());
-if (((((*this).current())).index() == 9 /* LCurly */)){
-((((*this).index)++));
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("operator is not an operator"sv)))));
 }
-NonnullRefPtr<typename parser::ParsedType> const inner = TRY((((*this).parse_typename())));
-if (((((*this).current())).index() == 10 /* RCurly */)){
-((((*this).index)++));
-return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Set>(inner,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
-TRY((((*this).error(Jakt::DeprecatedString("Expected '}'"sv),((((*this).current())).span())))));
-return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
+return (((expr_stack)[static_cast<i64>(0LL)]));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_operand_base() {
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_operator(bool const allow_assignments) {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+utility::Span const span = ((((*this).current())).span());
+parser::BinaryOperator const op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::BinaryOperator, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 53: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_90; {
-__jakt_var_90 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("this"sv),span))); goto __jakt_label_86;
-
-}
-__jakt_label_86:; __jakt_var_90.release_value(); }));
+case 50: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::NoneCoalescing() } );
 };/*case end*/
-case 101: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_91; {
-((((*this).index)++));
-__jakt_var_91 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 9: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_try_block()))));
+case 14: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Add() } );
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_92; {
-NonnullRefPtr<typename parser::ParsedExpression> const expression = TRY((((*this).parse_expression(true,true))));
-JaktInternal::Optional<parser::ParsedBlock> catch_block = JaktInternal::OptionalNone();
-JaktInternal::Optional<DeprecatedString> catch_name = JaktInternal::OptionalNone();
-if (((((*this).current())).index() == 64 /* Catch */)){
-((((*this).index)++));
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-(catch_name = name);
-((((*this).index)++));
-}
-(catch_block = TRY((((*this).parse_block()))));
-}
-__jakt_var_92 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Try>(expression,catch_block,catch_name,span))); goto __jakt_label_88;
-
-}
-__jakt_label_88:; __jakt_var_92.release_value(); }));
+case 15: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Subtract() } );
 };/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_87;
-
-}
-__jakt_label_87:; __jakt_var_91.release_value(); }));
+case 36: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Multiply() } );
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_93; {
-((((*this).index)++));
-__jakt_var_93 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::QuotedString>(quote,span))); goto __jakt_label_89;
-
-}
-__jakt_label_89:; __jakt_var_93.release_value(); }));
+case 47: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Divide() } );
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
-JaktInternal::Optional<DeprecatedString> const& prefix = __jakt_match_value.prefix;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_94; {
-((((*this).index)++));
-__jakt_var_94 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::SingleQuotedString>(quote,prefix,span))); goto __jakt_label_90;
-
-}
-__jakt_label_90:; __jakt_var_94.release_value(); }));
+case 13: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Modulo() } );
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();lexer::LiteralPrefix const& prefix = __jakt_match_value.prefix;
-DeprecatedString const& number = __jakt_match_value.number;
-lexer::LiteralSuffix const& suffix = __jakt_match_value.suffix;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).parse_number(prefix,number,suffix,span)))));
+case 59: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::LogicalAnd() } );
 };/*case end*/
-case 100: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_95; {
-((((*this).index)++));
-__jakt_var_95 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Boolean>(true,span))); goto __jakt_label_91;
+case 87: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::LogicalOr() } );
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Equal() } );
+};/*case end*/
+case 24: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::NotEqual() } );
+};/*case end*/
+case 28: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::LessThan() } );
+};/*case end*/
+case 29: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::LessThanOrEqual() } );
+};/*case end*/
+case 26: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::GreaterThan() } );
+};/*case end*/
+case 27: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::GreaterThanOrEqual() } );
+};/*case end*/
+case 37: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseAnd() } );
+};/*case end*/
+case 39: {
+return JaktInternal::ExplicitValue(({ Optional<parser::BinaryOperator> __jakt_var_81; {
+TRY((((*this).error(Jakt::DeprecatedString("‘&&’ is not allowed, use ‘and’ instead"sv),span))));
+__jakt_var_81 =  parser::BinaryOperator { typename parser::BinaryOperator::LogicalAnd() } ; goto __jakt_label_78;
 
 }
-__jakt_label_91:; __jakt_var_95.release_value(); }));
+__jakt_label_78:; __jakt_var_81.release_value(); }));
 };/*case end*/
-case 73: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_96; {
-((((*this).index)++));
-__jakt_var_96 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Boolean>(false,span))); goto __jakt_label_92;
+case 40: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseOr() } );
+};/*case end*/
+case 42: {
+return JaktInternal::ExplicitValue(({ Optional<parser::BinaryOperator> __jakt_var_82; {
+TRY((((*this).error(Jakt::DeprecatedString("‘||’ is not allowed, use ‘or’ instead"sv),span))));
+__jakt_var_82 =  parser::BinaryOperator { typename parser::BinaryOperator::LogicalOr() } ; goto __jakt_label_79;
 
 }
-__jakt_label_92:; __jakt_var_96.release_value(); }));
+__jakt_label_79:; __jakt_var_82.release_value(); }));
 };/*case end*/
-case 97: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_97; {
-((((*this).index)++));
-__jakt_var_97 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("this"sv),span))); goto __jakt_label_93;
-
-}
-__jakt_label_93:; __jakt_var_97.release_value(); }));
+case 43: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseXor() } );
 };/*case end*/
-case 86: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_98; {
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
-__jakt_var_98 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::LogicalNot() } ,span))); goto __jakt_label_94;
-
-}
-__jakt_label_94:; __jakt_var_98.release_value(); }));
+case 31: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseLeftShift() } );
 };/*case end*/
-case 46: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_99; {
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
-__jakt_var_99 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::BitwiseNot() } ,span))); goto __jakt_label_95;
-
-}
-__jakt_label_95:; __jakt_var_99.release_value(); }));
+case 33: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseRightShift() } );
 };/*case end*/
-case 95: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_100; {
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedType> const parsed_type = TRY((((*this).parse_typename())));
-utility::Span const span = TRY((parser::merge_spans(start,((parsed_type)->span()))));
-__jakt_var_100 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))), parser::UnaryOperator { typename parser::UnaryOperator::Sizeof(parsed_type) } ,span))); goto __jakt_label_96;
-
-}
-__jakt_label_96:; __jakt_var_100.release_value(); }));
+case 30: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::ArithmeticLeftShift() } );
 };/*case end*/
-case 92: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_101; {
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedType> const type = TRY((((*this).parse_typename())));
-utility::Span const span = TRY((parser::merge_spans(start,((type)->span()))));
-__jakt_var_101 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Reflect>(type,span))); goto __jakt_label_97;
-
+case 34: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::ArithmeticRightShift() } );
+};/*case end*/
+case 16: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::Assign() } );
+};/*case end*/
+case 32: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseLeftShiftAssign() } );
+};/*case end*/
+case 35: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseRightShiftAssign() } );
+};/*case end*/
+case 38: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseAndAssign() } );
+};/*case end*/
+case 41: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseOrAssign() } );
+};/*case end*/
+case 44: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::BitwiseXorAssign() } );
+};/*case end*/
+case 17: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::AddAssign() } );
+};/*case end*/
+case 19: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::SubtractAssign() } );
+};/*case end*/
+case 21: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::MultiplyAssign() } );
+};/*case end*/
+case 22: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::DivideAssign() } );
+};/*case end*/
+case 23: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::ModuloAssign() } );
+};/*case end*/
+case 51: {
+return JaktInternal::ExplicitValue( parser::BinaryOperator { typename parser::BinaryOperator::NoneCoalescingAssign() } );
+};/*case end*/
+default: {
+{
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
-__jakt_label_97:; __jakt_var_101.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_102; {
-if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 7 /* LParen */)){
-if ((name == Jakt::DeprecatedString("Some"sv))){
+}/*switch end*/
+}()
+));
 ((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::OptionalSome>(expr,span))));
-}
-JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>((call.value()),span))));
-}
-if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 28 /* LessThan */)){
-(((((*this).compiler))->ignore_parser_errors) = true);
-JaktInternal::Optional<parser::ParsedCall> const call = TRY((((*this).parse_call())));
-(((((*this).compiler))->ignore_parser_errors) = false);
-if ((!(((call).has_value())))){
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>,ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto __jakt_enum_value = (name);
-if (__jakt_enum_value == Jakt::DeprecatedString("None"sv)) {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::OptionalNone>(span))));
-}
-else {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(name,span))));
-}
-}()))
-);
+if (((!(allow_assignments)) && ((op).is_assignment()))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment is not allowed in this position"sv),span))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Operator>(op,span))));
 }
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>((call.value()),span))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Operator>(op,span))));
 }
-((((*this).index)++));
-if ((name == Jakt::DeprecatedString("None"sv))){
-return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::OptionalNone>(span))));
 }
-__jakt_var_102 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(name,span))); goto __jakt_label_98;
 
-}
-__jakt_label_98:; __jakt_var_102.release_value(); }));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_103; {
+ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parser::Parser::parse_for_statement() {
+{
 utility::Span const start_span = ((((*this).current())).span());
 ((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> expr = TRY((((*this).parse_expression(false,false))));
-((*this).skip_newlines());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+DeprecatedString iterator_name = Jakt::DeprecatedString(""sv);
+JaktInternal::DynamicArray<parser::ParsedVarDecl> destructured_var_decls = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
+utility::Span name_span = ((((*this).current())).span());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 8: {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
 {
+(iterator_name = name);
 ((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 52: {
+case 7: {
 {
-((((*this).index)++));
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> tuple_exprs = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>>::create_with({expr}))));
-utility::Span end_span = start_span;
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 55: {
+parser::ParsedVarDeclTuple const destructured_assignment = TRY((((*this).parse_destructuring_assignment(false))));
+(destructured_var_decls = ((destructured_assignment).var_decls));
+DeprecatedString tuple_var_name = Jakt::DeprecatedString(""sv);
 {
-((((*this).index)++));
+JaktInternal::ArrayIterator<parser::ParsedVarDecl> _magic = ((destructured_var_decls).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedVarDecl> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 52: {
+parser::ParsedVarDecl var = (_magic_value.value());
 {
-((((*this).index)++));
+(tuple_var_name += ((var).name));
+(tuple_var_name += Jakt::DeprecatedString("__"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 8: {
-{
-((((*this).index)++));
-return JaktInternal::LoopBreak{};
+
+}
+}
+
+(name_span = ((destructured_assignment).span));
+(iterator_name = tuple_var_name);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
-(end_span = ((expr)->span()));
-TRY((((tuple_exprs).push(expr))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected iterator name or destructuring pattern"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Garbage>(TRY((parser::merge_spans(start_span,((((*this).current())).span()))))))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
+if (((((*this).current())).index() == 79 /* In */)){
+((((*this).index)++));
 }
-if (((*this).eof())){
-TRY((((*this).error(Jakt::DeprecatedString("Expected ')'"sv),((((*this).current())).span())))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘in’"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Garbage>(TRY((parser::merge_spans(start_span,((((*this).current())).span()))))))));
 }
-(expr = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::JaktTuple>(tuple_exprs,TRY((parser::merge_spans(start_span,end_span)))))));
+
+bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
+(((*this).can_have_trailing_closure) = false);
+NonnullRefPtr<typename parser::ParsedExpression> const range = TRY((((*this).parse_expression(false,false))));
+(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
+bool is_destructuring = false;
+parser::ParsedBlock block = TRY((((*this).parse_block())));
+if ((((destructured_var_decls).size()) > static_cast<size_t>(0ULL))){
+(is_destructuring = true);
+DeprecatedString tuple_var_name = Jakt::DeprecatedString("jakt__"sv);
+(tuple_var_name += iterator_name);
+parser::ParsedVarDecl tuple_var_decl = parser::ParsedVarDecl(tuple_var_name,TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),false,JaktInternal::OptionalNone(),((((*this).current())).span()));
+NonnullRefPtr<typename parser::ParsedExpression> const init = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(iterator_name,TRY((parser::merge_spans(start_span,((((*this).previous())).span())))))));
+NonnullRefPtr<typename parser::ParsedStatement> const var_decl = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(tuple_var_decl,init,TRY((parser::merge_spans(start_span,((((*this).previous())).span())))))));
+NonnullRefPtr<typename parser::ParsedStatement> const destructured_vars_stmt = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::DestructuringAssignment>(destructured_var_decls,var_decl,TRY((parser::merge_spans(start_span,((((*this).previous())).span())))))));
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> block_stmts = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({}))));
+TRY((((block_stmts).push(destructured_vars_stmt))));
+TRY((((block_stmts).push_values(((((block).stmts)))))));
+(((block).stmts) = block_stmts);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+return (TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::For>(iterator_name,name_span,is_destructuring,range,block,TRY((parser::merge_spans(start_span,((((*this).previous())).span()))))))));
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_operand() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected ')'"sv),((((*this).current())).span())))));
+((*this).skip_newlines());
+utility::Span const start = ((((*this).current())).span());
+((*this).skip_newlines());
+NonnullRefPtr<typename parser::ParsedExpression> expr = TRY((((*this).parse_operand_base())));
+return (TRY((((*this).parse_operand_postfix_operator(start,expr)))));
+}
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-__jakt_var_103 = expr; goto __jakt_label_99;
 
+ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parser::Parser::parse_sum_enum_body(parser::ParsedRecord const partial_enum,parser::DefinitionLinkage const definition_linkage,bool const is_boxed) {
+{
+JaktInternal::DynamicArray<parser::ParsedMethod> methods = (TRY((DynamicArray<parser::ParsedMethod>::create_with({}))));
+JaktInternal::DynamicArray<parser::SumEnumVariant> variants = (TRY((DynamicArray<parser::SumEnumVariant>::create_with({}))));
+JaktInternal::DynamicArray<parser::ParsedField> fields = (TRY((DynamicArray<parser::ParsedField>::create_with({}))));
+bool seen_a_variant = false;
+if (((((*this).current())).index() == 9 /* LCurly */)){
+((((*this).index)++));
 }
-__jakt_label_99:; __jakt_var_103.release_value(); }));
-};/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_104; {
-parser::UnaryOperator const op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::UnaryOperator, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 18: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreIncrement() } );
-};/*case end*/
-case 20: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreDecrement() } );
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::Negate() } );
-};/*case end*/
-default: {
-{
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("unreachable"sv)))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
-__jakt_var_104 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr,op,span))); goto __jakt_label_100;
-
-}
-__jakt_label_100:; __jakt_var_104.release_value(); }));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_105; {
-parser::UnaryOperator const op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::UnaryOperator, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 18: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreIncrement() } );
-};/*case end*/
-case 20: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreDecrement() } );
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::Negate() } );
-};/*case end*/
-default: {
-{
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("unreachable"sv)))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected `{` to start the enum body"sv),((((*this).current())).span())))));
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
-__jakt_var_105 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr,op,span))); goto __jakt_label_101;
 
+((*this).skip_newlines());
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete enum definition, expected variant or field name"sv),((((*this).previous())).span())))));
+return ((Tuple{variants, fields, methods}));
 }
-__jakt_label_101:; __jakt_var_105.release_value(); }));
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_106; {
-parser::UnaryOperator const op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::UnaryOperator, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+JaktInternal::Optional<parser::Visibility> last_visibility = JaktInternal::OptionalNone();
+JaktInternal::Optional<utility::Span> last_visibility_span = JaktInternal::OptionalNone();
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 18: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreIncrement() } );
-};/*case end*/
-case 20: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::PreDecrement() } );
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue( parser::UnaryOperator { typename parser::UnaryOperator::Negate() } );
-};/*case end*/
-default: {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("unreachable"sv)))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-utility::Span const start = ((((*this).current())).span());
-((((*this).index)++));
-NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
-utility::Span const span = TRY((parser::merge_spans(start,((expr)->span()))));
-__jakt_var_106 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr,op,span))); goto __jakt_label_102;
-
-}
-__jakt_label_102:; __jakt_var_106.release_value(); }));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_107; {
-__jakt_var_107 = TRY((((*this).parse_array_or_dictionary_literal()))); goto __jakt_label_103;
-
+if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 5 /* Colon */)){
+parser::ParsedField const field = TRY((((*this).parse_field(last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; })))));
+if (seen_a_variant){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Common enum fields must be declared before variants"sv),span,Jakt::DeprecatedString("Previous variant is here"sv),(((((variants).last()).value())).span)))));
 }
-__jakt_label_103:; __jakt_var_107.release_value(); }));
-};/*case end*/
-case 83: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_108; {
-__jakt_var_108 = TRY((((*this).parse_match_expression()))); goto __jakt_label_104;
-
+else {
+TRY((((fields).push(field))));
 }
-__jakt_label_104:; __jakt_var_108.release_value(); }));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_109; {
-__jakt_var_109 = TRY((((*this).parse_set_literal()))); goto __jakt_label_105;
 
+return JaktInternal::LoopContinue{};
 }
-__jakt_label_105:; __jakt_var_109.release_value(); }));
-};/*case end*/
-case 37: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_ampersand()))));
-};/*case end*/
-case 36: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_asterisk()))));
-};/*case end*/
-case 75: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_lambda()))));
-};/*case end*/
-case 54: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_range()))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_110; {
-utility::Span const span = ((((*this).current())).span());
+(seen_a_variant = true);
+if ((!(((((*this).peek(static_cast<size_t>(1ULL)))).index() == 7 /* LParen */)))){
 ((((*this).index)++));
-TRY((((*this).error(Jakt::DeprecatedString("Unsupported expression"sv),span))));
-__jakt_var_110 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))); goto __jakt_label_106;
-
+TRY((((variants).push(parser::SumEnumVariant(name,span,JaktInternal::OptionalNone())))));
+return JaktInternal::LoopContinue{};
 }
-__jakt_label_106:; __jakt_var_110.release_value(); }));
-};/*case end*/
-}/*switch end*/
-}()
-)));
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
+JaktInternal::DynamicArray<parser::ParsedVarDecl> var_decls = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
+while ((!(((*this).eof())))){
+if (((((*this).peek(static_cast<size_t>(1ULL)))).index() == 5 /* Colon */)){
+parser::ParsedVarDecl var_decl = TRY((((*this).parse_variable_declaration(false))));
+if (((((var_decl).parsed_type))->index() == 0 /* Name */)){
+DeprecatedString const name = ((((var_decl).parsed_type))->get<parser::ParsedType::Name>()).name;
+utility::Span const span = ((((var_decl).parsed_type))->get<parser::ParsedType::Name>()).span;
+(((var_decl).inlay_span) = span);
+if (((name == ((partial_enum).name)) && (!(is_boxed)))){
+TRY((((*this).error(Jakt::DeprecatedString("use 'boxed enum' to make the enum recursive"sv),((var_decl).span)))));
 }
 }
-
-ErrorOr<parser::ParsedAlias> parser::Parser::parse_using() {
-{
-parser::ParsedAlias alias = parser::ParsedAlias(JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedNameWithGenericParameters>::create_with({})))));
-for (;;){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedAlias>>{
+TRY((((var_decls).push(var_decl))));
+continue;
+}
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 55: {
+case 3: {
 {
-return JaktInternal::LoopBreak{};
+TRY((((var_decls).push(parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((((*this).parse_typename()))),false,JaktInternal::OptionalNone(),((((*this).current())).span()))))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 61: {
+case 11: {
 {
-return JaktInternal::LoopBreak{};
+TRY((((var_decls).push(parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((((*this).parse_typename()))),false,JaktInternal::OptionalNone(),((((*this).current())).span()))))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 56: {
+case 9: {
 {
-return JaktInternal::LoopBreak{};
+TRY((((var_decls).push(parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((((*this).parse_typename()))),false,JaktInternal::OptionalNone(),((((*this).current())).span()))))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 6: {
+default: {
 {
-((((*this).index)++));
-return JaktInternal::LoopContinue{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-{
-parser::ParsedNameWithGenericParameters parsed_name = parser::ParsedNameWithGenericParameters(name,span,(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({})))));
-((((*this).index)++));
-if (((((*this).current())).index() == 28 /* LessThan */)){
-((((*this).index)++));
-while ((!(((*this).eof())))){
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedAlias>>{
+}/*switch end*/
+}()
+));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 26: {
+case 8: {
 {
 ((((*this).index)++));
 return JaktInternal::LoopBreak{};
@@ -8351,2406 +7971,2659 @@ case 55: {
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 33: {
-{
-TRY((((*this).inject_token( lexer::Token { typename lexer::Token::GreaterThan(((((*this).current())).span())) } ))));
-({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
 default: {
 {
-size_t const index_before = ((*this).index);
-NonnullRefPtr<typename parser::ParsedType> const inner_type = TRY((((*this).parse_typename())));
-if ((index_before == ((*this).index))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected type name"sv),((((*this).current())).span())))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Incomplete enum variant defintion, expected `,` or `)`; got ‘{}’"sv),((*this).current())))),((((*this).current())).span())))));
 return JaktInternal::LoopBreak{};
 }
-TRY((((((parsed_name).generic_parameters)).push(inner_type))));
-}
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
 }
-}
-TRY((((((alias).target)).push(parsed_name))));
+TRY((((variants).push(parser::SumEnumVariant(name,span,var_decls)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
+case 10: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();utility::Span const& span = __jakt_match_value.span;
+case 52: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();utility::Span const& span = __jakt_match_value.span;
+case 55: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Semicolon>();
+case 89: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if (((last_visibility).has_value())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+}
+(last_visibility =  parser::Visibility { typename parser::Visibility::Private() } );
+(last_visibility_span = span);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Colon>();
+case 90: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if (((last_visibility).has_value())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Multiple visibility modifiers on one field or method are not allowed"sv),span,Jakt::DeprecatedString("Previous modifier is here"sv),(last_visibility_span.value())))));
+}
+(last_visibility =  parser::Visibility { typename parser::Visibility::Public() } );
+(last_visibility_span = span);
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
-utility::Span const& span = __jakt_match_value.value;
+case 75: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
+bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
+parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = definition_linkage;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RParen>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
+case 1: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LCurly>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
+TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
+}
+parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; });
+(last_visibility = JaktInternal::OptionalNone());
+(last_visibility_span = JaktInternal::OptionalNone());
+parser::ParsedMethod const parsed_method = TRY((((*this).parse_method(function_linkage,visibility,false,false,is_comptime,false))));
+TRY((((methods).push(parsed_method))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RCurly>();
-utility::Span const& span = __jakt_match_value.value;
+case 76: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+bool const is_comptime = ((((*this).current())).index() == 76 /* Comptime */);
+parser::FunctionLinkage const function_linkage = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::FunctionLinkage, ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>>>{
+auto&& __jakt_match_variant = definition_linkage;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+if ((((function_linkage).index() == 1 /* External */) && is_comptime)){
+TRY((((*this).error(Jakt::DeprecatedString("External functions cannot be comptime"sv),((((*this).current())).span())))));
+}
+parser::Visibility const visibility = last_visibility.value_or_lazy_evaluated([&] { return  parser::Visibility { typename parser::Visibility::Public() } ; });
+(last_visibility = JaktInternal::OptionalNone());
+(last_visibility_span = JaktInternal::OptionalNone());
+parser::ParsedMethod const parsed_method = TRY((((*this).parse_method(function_linkage,visibility,false,false,is_comptime,false))));
+TRY((((methods).push(parsed_method))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LSquare>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected identifier or the end of enum block"sv),((((*this).current())).span())))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
+}/*switch end*/
+}()
+));
+}
+if ((!(((((*this).current())).index() == 10 /* RCurly */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Invalid enum definition, expected `}`"sv),((((*this).current())).span())))));
+return ((Tuple{variants, fields, methods}));
+}
+((((*this).index)++));
+if (((variants).is_empty())){
+TRY((((*this).error(Jakt::DeprecatedString("Empty enums are not allowed"sv),((partial_enum).name_span)))));
+}
+return ((Tuple{variants, fields, methods}));
+}
+}
+
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedCapture>> parser::Parser::parse_captures() {
+{
+JaktInternal::DynamicArray<parser::ParsedCapture> captures = (TRY((DynamicArray<parser::ParsedCapture>::create_with({}))));
+if (((((*this).current())).index() == 11 /* LSquare */)){
+((((*this).index)++));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::ParsedCapture>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
 case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RSquare>();
-utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
+((((*this).index)++));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSign>();
-utility::Span const& span = __jakt_match_value.value;
+case 37: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Plus>();
-utility::Span const& span = __jakt_match_value.value;
+((((*this).index)++));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::ParsedCapture>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 84: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByMutableReference(name,((((*this).current())).span())) } ))));
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected identifier, got '{}'"sv),((*this).current())))),((((*this).current())).span())))));
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Equal>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusEqual>();
-utility::Span const& span = __jakt_match_value.value;
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByReference(name,((((*this).current())).span())) } ))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected identifier or mut, got '{}'"sv),((*this).current())))),((((*this).current())).span())))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+}/*switch end*/
+}()
+));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
-utility::Span const& span = __jakt_match_value.value;
+case 76: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByComptimeDependency(name,((((*this).current())).span())) } ))));
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AsteriskEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected identifier, got '{}'"sv),((*this).current())))),((((*this).current())).span())))));
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlashEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSignEqual>();
-utility::Span const& span = __jakt_match_value.value;
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByValue(name,((((*this).current())).span())) } ))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::NotEqual>();
-utility::Span const& span = __jakt_match_value.value;
+case 97: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((captures).push( parser::ParsedCapture { typename parser::ParsedCapture::ByValue(Jakt::DeprecatedString("this"sv),((((*this).current())).span())) } ))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DoubleEqual>();
-utility::Span const& span = __jakt_match_value.value;
+case 52: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThan>();
-utility::Span const& span = __jakt_match_value.value;
+case 55: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThanOrEqual>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unexpected token '{}' in captures list"sv),((*this).current())))),((((*this).current())).span())))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThan>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+}/*switch end*/
+}()
+));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThanOrEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+return (captures);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 30: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftArithmeticShift>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+return ((TRY((DynamicArray<parser::ParsedCapture>::create_with({})))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 31: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShift>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 32: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShiftEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 33: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShift>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_number(lexer::LiteralPrefix const prefix,DeprecatedString const number,lexer::LiteralSuffix suffix,utility::Span const span) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 34: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightArithmeticShift>();
-utility::Span const& span = __jakt_match_value.value;
+((((*this).index)++));
+u64 total = static_cast<u64>(0ULL);
+if ((!(((prefix).index() == 0 /* None */)))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = prefix;
+switch(__jakt_match_variant.index()) {
+case 1: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if ((((number).length()) == static_cast<size_t>(0ULL))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not parse hexadecimal number due to no digits"sv)))),span))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 35: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShiftEqual>();
-utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+DeprecatedStringCodePointIterator _magic = ((number).code_points());
+for (;;){
+JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 36: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Asterisk>();
-utility::Span const& span = __jakt_match_value.value;
+u32 cp = (_magic_value.value());
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+u8 const byte = as_saturated<u8, u32>(cp);
+if ((byte != '_')){
+u8 offset = static_cast<u8>(0);
+if (((byte >= 'a') && (byte <= 'z'))){
+(offset = static_cast<u8>(39));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 37: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Ampersand>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else if (((byte >= 'A') && (byte <= 'Z'))){
+(offset = static_cast<u8>(7));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 38: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+u8 const value = (JaktInternal::checked_sub<u8>(byte,offset));
+u64 const digit = as_saturated<u64, u8>((JaktInternal::checked_sub<u8>(value,'0')));
+(total = (JaktInternal::checked_add<u64>((JaktInternal::checked_mul<u64>(total,static_cast<u64>(16ULL))),digit)));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 39: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandAmpersand>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 40: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Pipe>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 41: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipeEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 42: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipePipe>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 43: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Caret>();
-utility::Span const& span = __jakt_match_value.value;
+case 2: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if ((((number).length()) == static_cast<size_t>(0ULL))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not parse octal number due to no digits"sv)))),span))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 44: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::CaretEqual>();
-utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+DeprecatedStringCodePointIterator _magic = ((number).code_points());
+for (;;){
+JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 45: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dollar>();
-utility::Span const& span = __jakt_match_value.value;
+u32 cp = (_magic_value.value());
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+u8 const byte = as_saturated<u8, u32>(cp);
+if ((byte != '_')){
+u64 const digit = as_saturated<u64, u8>((JaktInternal::checked_sub<u8>(byte,'0')));
+(total = (JaktInternal::checked_add<u64>((JaktInternal::checked_mul<u64>(total,static_cast<u64>(8ULL))),digit)));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 46: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 47: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlash>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 48: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ExclamationPoint>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 49: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMark>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 50: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMark>();
-utility::Span const& span = __jakt_match_value.value;
+case 3: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if ((((number).length()) == static_cast<size_t>(0ULL))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not parse binary number due to no digits"sv)))),span))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 51: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMarkEqual>();
-utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+DeprecatedStringCodePointIterator _magic = ((number).code_points());
+for (;;){
+JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 52: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comma>();
-utility::Span const& span = __jakt_match_value.value;
+u32 cp = (_magic_value.value());
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+u8 const byte = as_saturated<u8, u32>(cp);
+if ((byte != '_')){
+u64 const digit = as_saturated<u64, u8>((JaktInternal::checked_sub<u8>(byte,'0')));
+(total = (JaktInternal::checked_add<u64>((JaktInternal::checked_mul<u64>(total,static_cast<u64>(2ULL))),digit)));
+}
+}
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 53: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+}
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 54: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DotDot>();
-utility::Span const& span = __jakt_match_value.value;
+case 0: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 57: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::FatArrow>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+JaktInternal::Optional<parser::NumericConstant> const constant_value = TRY((((*this).make_integer_numeric_constant(total,suffix,span))));
+if (((constant_value).has_value())){
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::NumericConstant>((constant_value.value()),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 58: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Arrow>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 59: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::And>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+bool number_too_large = false;
+bool floating = false;
+u64 fraction_nominator = static_cast<u64>(0ULL);
+u64 fraction_denominator = static_cast<u64>(1ULL);
+if ((((number).length()) == static_cast<size_t>(0ULL))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not parse number due to no digits"sv)))),span))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 60: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Anon>();
-utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+DeprecatedStringCodePointIterator _magic = ((number).code_points());
+for (;;){
+JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 62: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Boxed>();
-utility::Span const& span = __jakt_match_value.value;
+u32 cp = (_magic_value.value());
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+u8 const byte = as_saturated<u8, u32>(cp);
+if ((byte != '_')){
+if ((byte == '.')){
+(floating = true);
+continue;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 63: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Break>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+u64 const digit = as_saturated<u64, u8>((JaktInternal::checked_sub<u8>(byte,'0')));
+if (floating){
+(fraction_nominator = (JaktInternal::checked_add<u64>((JaktInternal::checked_mul<u64>(fraction_nominator,static_cast<u64>(10ULL))),digit)));
+({auto& _jakt_ref = fraction_denominator;_jakt_ref = JaktInternal::checked_mul<u64>(_jakt_ref, static_cast<u64>(10ULL));});
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 64: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Catch>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+u64 const old_total = total;
+(total = unchecked_add<u64>(unchecked_mul<u64>(total,static_cast<u64>(10ULL)),digit));
+if ((total < old_total)){
+(number_too_large = true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 65: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Class>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 66: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Continue>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
-return JaktInternal::ExplicitValue<void>();
+}
+
+}
+}
+
+if (number_too_large){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Integer literal too large"sv)))),span))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
+}
+if ((floating && ((suffix).index() == 0 /* None */))){
+(suffix =  lexer::LiteralSuffix { typename lexer::LiteralSuffix::F64() } );
+}
+bool const is_float_suffix = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = suffix;
+switch(__jakt_match_variant.index()) {
+case 10: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 67: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Cpp>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+case 11: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+));
+if ((floating && (!(is_float_suffix)))){
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
 }
-return JaktInternal::ExplicitValue<void>();
+JaktInternal::Optional<parser::NumericConstant> const constant_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<parser::NumericConstant>, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
+auto&& __jakt_match_variant = suffix;
+switch(__jakt_match_variant.index()) {
+case 10: {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<parser::NumericConstant>> __jakt_var_83; {
+f64 const number = (parser::u64_to_float<f64>(total) + (parser::u64_to_float<f64>(fraction_nominator) / parser::u64_to_float<f64>(fraction_denominator)));
+__jakt_var_83 = TRY((((*this).make_float_numeric_constant(number,suffix,span)))); goto __jakt_label_80;
+
+}
+__jakt_label_80:; __jakt_var_83.release_value(); }));
 };/*case end*/
-case 68: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Defer>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+case 11: {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<parser::NumericConstant>> __jakt_var_84; {
+f64 const number = (parser::u64_to_float<f64>(total) + (parser::u64_to_float<f64>(fraction_nominator) / parser::u64_to_float<f64>(fraction_denominator)));
+__jakt_var_84 = TRY((((*this).make_float_numeric_constant(number,suffix,span)))); goto __jakt_label_81;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_81:; __jakt_var_84.release_value(); }));
 };/*case end*/
-case 69: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Destructor>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
+return JaktInternal::ExplicitValue(TRY((((*this).make_integer_numeric_constant(total,suffix,span)))));
+};/*case end*/
+}/*switch end*/
+}()
+));
+if (((constant_value).has_value())){
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::NumericConstant>((constant_value.value()),span))));
+}
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(span))));
+}
+}
+
+ErrorOr<parser::ParsedModuleImport> parser::Parser::parse_module_import() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+parser::ParsedModuleImport parsed_import = parser::ParsedModuleImport( parser::ImportName { typename parser::ImportName::Literal(Jakt::DeprecatedString(""sv),((*this).empty_span())) } ,JaktInternal::OptionalNone(), parser::ImportList { typename parser::ImportList::List((TRY((DynamicArray<parser::ImportName>::create_with({}))))) } );
+(((parsed_import).module_name) = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ImportName, ErrorOr<parser::ParsedModuleImport>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ImportName, ErrorOr<parser::ParsedModuleImport>>{
+auto&& __jakt_match_variant = ((*this).peek(static_cast<size_t>(1ULL)));
+switch(__jakt_match_variant.index()) {
+case 7: {
+return JaktInternal::ExplicitValue(({ Optional<parser::ImportName> __jakt_var_85; {
+bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
+(((*this).can_have_trailing_closure) = false);
+NonnullRefPtr<typename parser::ParsedExpression> const expression = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Call>((TRY((((*this).parse_call()))).value()),span)));
+(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
+((((*this).index)--));
+__jakt_var_85 =  parser::ImportName { typename parser::ImportName::Comptime(expression) } ; goto __jakt_label_82;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_82:; __jakt_var_85.release_value(); }));
 };/*case end*/
-case 70: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Else>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
+return JaktInternal::ExplicitValue( parser::ImportName { typename parser::ImportName::Literal(name,span) } );
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected module name"sv),((((*this).current())).span())))));
+return (parsed_import);
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 71: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Enum>();
-utility::Span const& span = __jakt_match_value.value;
+}/*switch end*/
+}()
+)));
+((((*this).index)++));
+if (((*this).eol())){
+return (parsed_import);
+}
+if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
+DeprecatedString module_name = ((((parsed_import).module_name)).literal_name());
+utility::Span module_span = ((((parsed_import).module_name)).span());
+while (((((*this).current())).index() == 6 /* ColonColon */)){
+((((*this).index)++));
+(module_name += Jakt::DeprecatedString("::"sv));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedModuleImport>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+(module_name += name);
+(module_span = TRY((parser::merge_spans(module_span,span))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 72: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Extern>();
-utility::Span const& span = __jakt_match_value.value;
+case 61: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 73: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
-utility::Span const& span = __jakt_match_value.value;
+case 9: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 74: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::For>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected module name fragment"sv),((((*this).current())).span())))));
+return (parsed_import);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 75: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Fn>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+}/*switch end*/
+}()
+));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 76: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comptime>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+(((parsed_import).module_name) =  parser::ImportName { typename parser::ImportName::Literal(module_name,module_span) } );
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 77: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::If>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if (((((*this).current())).index() == 61 /* As */)){
+((((*this).index)++));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
+((((*this).index)++));
+(((parsed_import).alias_name) =  parser::ImportName { typename parser::ImportName::Literal(name,span) } );
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 78: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Import>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected name"sv),((((*this).current())).span())))));
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 79: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::In>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 80: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Is>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if (((*this).eol())){
+return (parsed_import);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 81: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Let>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if ((!(((((*this).current())).index() == 9 /* LCurly */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected '{'"sv),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 82: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Loop>();
-utility::Span const& span = __jakt_match_value.value;
+((((*this).index)++));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedModuleImport>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if (((((parsed_import).import_list)).index() == 0 /* List */)){
+JaktInternal::DynamicArray<parser::ImportName> const names = ((((parsed_import).import_list)).get<parser::ImportList::List>()).value;
+JaktInternal::DynamicArray<parser::ImportName> mutable_names = names;
+TRY((((mutable_names).push( parser::ImportName { typename parser::ImportName::Literal(name,span) } ))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 83: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Match>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Already importing everything from '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span()),Jakt::DeprecatedString("Remove the '*' to import specific names"sv),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 84: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Mut>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 85: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Namespace>();
-utility::Span const& span = __jakt_match_value.value;
+case 36: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if (((((parsed_import).import_list)).index() == 0 /* List */)){
+JaktInternal::DynamicArray<parser::ImportName> const names = ((((parsed_import).import_list)).get<parser::ImportList::List>()).value;
+if (((names).is_empty())){
+(((parsed_import).import_list) =  parser::ImportList { typename parser::ImportList::All() } );
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 86: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+if (((((parsed_import).import_list)).index() == 1 /* All */)){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot repeat '*' in import list for '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 87: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Or>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot mix '*' and specific names in import list for '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 88: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Override>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 89: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 90: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+if (((((parsed_import).import_list)).index() == 1 /* All */)){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot repeat '*' in import list for '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 91: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Raw>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot mix '*' and specific names in import list for '{}'"sv),((((parsed_import).module_name)).literal_name())))),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 92: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 93: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Return>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 94: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
-utility::Span const& span = __jakt_match_value.value;
+case 52: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 95: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
-utility::Span const& span = __jakt_match_value.value;
+case 55: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 96: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Struct>();
-utility::Span const& span = __jakt_match_value.value;
+case 10: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
+((((*this).index)++));
 return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 97: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+TRY((((*this).error(Jakt::DeprecatedString("Expected import symbol"sv),((((*this).current())).span())))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 98: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throw>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+}/*switch end*/
+}()
+));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 99: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throws>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+return (parsed_import);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 100: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 101: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<parser::ParsedRecord> parser::Parser::parse_record(parser::DefinitionLinkage const definition_linkage) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ParsedRecord, ErrorOr<parser::ParsedRecord>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 96: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_struct(definition_linkage)))));
 };/*case end*/
-case 102: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Unsafe>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
+case 65: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_class(definition_linkage)))));
 };/*case end*/
-case 103: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Virtual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
+case 71: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_enum(definition_linkage,false)))));
 };/*case end*/
-case 104: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Weak>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+case 62: {
+return JaktInternal::ExplicitValue(({ Optional<parser::ParsedRecord> __jakt_var_86; {
+((((*this).index)++));
+__jakt_var_86 = TRY((((*this).parse_enum(definition_linkage,true)))); goto __jakt_label_83;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_83:; __jakt_var_86.release_value(); }));
 };/*case end*/
-case 105: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::While>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+default: {
+return JaktInternal::ExplicitValue(({ Optional<parser::ParsedRecord> __jakt_var_87; {
+TRY((((*this).error(Jakt::DeprecatedString("Expected `struct`, `class`, `enum`, or `boxed`"sv),((((*this).current())).span())))));
+__jakt_var_87 = parser::ParsedRecord(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),definition_linkage,JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedMethod>::create_with({})))), parser::RecordType { typename parser::RecordType::Garbage() } ,JaktInternal::OptionalNone()); goto __jakt_label_84;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_84:; __jakt_var_87.release_value(); }));
 };/*case end*/
-case 106: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Yield>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+}/*switch end*/
+}()
+)));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 107: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Guard>();
-utility::Span const& span = __jakt_match_value.value;
+}
+
+lexer::Token parser::Parser::peek(size_t const steps) const {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if ((((*this).eof()) || ((JaktInternal::checked_add<size_t>(steps,((*this).index))) >= ((((*this).tokens)).size())))){
+return ((((((*this).tokens)).last()).value()));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 108: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Implements>();
-utility::Span const& span = __jakt_match_value.value;
+return (((((*this).tokens))[(JaktInternal::checked_add<size_t>(((*this).index),steps))]));
+}
+}
+
+ErrorOr<void> parser::Parser::error_with_hint(DeprecatedString const message,utility::Span const span,DeprecatedString const hint,utility::Span const hint_span) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+if ((!(((((*this).compiler))->ignore_parser_errors)))){
+TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::MessageWithHint(message,span,hint,hint_span) } ))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 109: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Requires>();
-utility::Span const& span = __jakt_match_value.value;
+}
+return {};
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_shorthand_array_or_dictionary() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+utility::Span const start = ((((*this).current())).span());
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedType> const inner = TRY((((*this).parse_typename())));
+if (((((*this).current())).index() == 12 /* RSquare */)){
+((((*this).index)++));
+return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::JaktArray>(inner,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 110: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Trait>();
-utility::Span const& span = __jakt_match_value.value;
+if (((((*this).current())).index() == 5 /* Colon */)){
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedType> const value = TRY((((*this).parse_typename())));
+if (((((*this).current())).index() == 12 /* RSquare */)){
+((((*this).index)++));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ']'"sv),((((*this).current())).span())))));
+}
+
+return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Dictionary>(inner,value,TRY((parser::merge_spans(start,((((*this).current())).span()))))))));
+}
+TRY((((*this).error(Jakt::DeprecatedString("Expected shorthand type"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_shorthand_tuple() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+utility::Span const start = ((((*this).current())).span());
+((((*this).index)++));
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> types = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))));
+while ((!(((*this).eof())))){
+if (((((*this).current())).index() == 8 /* RParen */)){
+((((*this).index)++));
+return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::JaktTuple>(types,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 111: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Garbage>();utility::Span const& span = __jakt_match_value.span;
+if (((((*this).current())).index() == 52 /* Comma */)){
+((((*this).index)++));
+}
+size_t const index_before = ((*this).index);
+NonnullRefPtr<typename parser::ParsedType> const type = TRY((((*this).parse_typename())));
+size_t const index_after = ((*this).index);
+if ((index_before == index_after)){
+break;
+}
+TRY((((types).push(type))));
+}
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘)’"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
+}
+}
+
+bool parser::Parser::eol() const {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
-return JaktInternal::LoopBreak{};
+return ((((*this).eof()) || ((((((*this).tokens))[((*this).index)])).index() == 55 /* Eol */)));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
 }
-if (((((*this).previous())).index() == 6 /* ColonColon */)){
-utility::Span const span = ((((*this).previous())).get<lexer::Token::ColonColon>()).value;
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias target name"sv),span))));
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_array_or_dictionary_literal() {
+{
+bool is_dictionary = false;
+utility::Span const start = ((((*this).current())).span());
+if ((!(((((*this).current())).index() == 11 /* LSquare */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘[’"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))));
 }
-if (((((*this).current())).index() == 61 /* As */)){
 ((((*this).index)++));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<parser::ParsedAlias>>{
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> fill_size_expr = JaktInternal::OptionalNone();
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> output = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>>::create_with({}))));
+JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> dict_output = (TRY((DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({}))));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
 auto&& __jakt_match_variant = ((*this).current());
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+case 12: {
 {
-(((alias).alias_name) = parser::ParsedName(name,span));
 ((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();utility::Span const& span = __jakt_match_value.span;
+case 52: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();utility::Span const& span = __jakt_match_value.span;
+case 55: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+((((*this).index)++));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Semicolon>();
-utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+if ((((output).size()) == static_cast<size_t>(1ULL))){
+((((*this).index)++));
+(fill_size_expr = TRY((((*this).parse_expression(false,false)))));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Can't fill an Array with more than one expression"sv),((((*this).current())).span())))));
+((((*this).index)++));
+}
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Colon>();
-utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+((((*this).index)++));
+if (((dict_output).is_empty())){
+if (((((*this).current())).index() == 12 /* RSquare */)){
+((((*this).index)++));
+(is_dictionary = true);
+return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ColonColon>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]’"sv),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Missing key in dictionary literal"sv),((((*this).current())).span())))));
+}
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RParen>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+if (((expr)->index() == 29 /* Garbage */)){
+return JaktInternal::LoopBreak{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LCurly>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+if (((((*this).current())).index() == 5 /* Colon */)){
+if ((!(((output).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Mixing dictionary and array values"sv),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RCurly>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+(is_dictionary = true);
+((((*this).index)++));
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Key missing value in dictionary"sv),((((*this).current())).span())))));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LSquare>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+NonnullRefPtr<typename parser::ParsedExpression> const value = TRY((((*this).parse_expression(false,false))));
+TRY((((dict_output).push((Tuple{expr, value})))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RSquare>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+else if ((!(is_dictionary))){
+TRY((((output).push(expr))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSign>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Plus>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}/*switch end*/
+}()
+));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
-utility::Span const& span = __jakt_match_value.value;
+size_t const end = (JaktInternal::checked_sub<size_t>(((*this).index),static_cast<size_t>(1ULL)));
+if (((end >= ((((*this).tokens)).size())) || (!(((((((*this).tokens))[end])).index() == 12 /* RSquare */))))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘]’ to close the array"sv),((((((*this).tokens))[end])).span())))));
+}
+if (is_dictionary){
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::JaktDictionary>(dict_output,TRY((parser::merge_spans(start,((((((*this).tokens))[end])).span()))))))));
+}
+else {
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::JaktArray>(output,fill_size_expr,TRY((parser::merge_spans(start,((((((*this).tokens))[end])).span()))))))));
+}
+
+}
+}
+
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchPattern>> parser::Parser::parse_match_patterns() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+JaktInternal::DynamicArray<parser::ParsedMatchPattern> patterns = (TRY((DynamicArray<parser::ParsedMatchPattern>::create_with({}))));
+((*this).skip_newlines());
+while ((!(((*this).eof())))){
+parser::ParsedMatchPattern pattern = TRY((((*this).parse_match_pattern())));
+ScopeGuard __jakt_var_88([&] {
+MUST((((patterns).push(pattern))));
+});
+JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults = ((pattern).defaults());
+((*this).skip_newlines());
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+if ((name == Jakt::DeprecatedString("default"sv))){
+JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults = ((pattern).defaults());
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+if ((!(((((*this).current())).index() == 7 /* LParen */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected '(' after 'default'"sv),((((*this).current())).span())))));
+continue;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+while (((!(((((*this).current())).index() == 8 /* RParen */))) && (!(((*this).eof()))))){
+bool const is_mutable = ((((*this).current())).index() == 84 /* Mut */);
+if (is_mutable){
+((((*this).index)++));
+}
+parser::ParsedVarDecl const declaration = TRY((((*this).parse_variable_declaration(is_mutable))));
+NonnullRefPtr<typename parser::ParsedExpression> const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchPattern>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
 case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Equal>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_89; {
+((((*this).index)++));
+__jakt_var_89 = TRY((((*this).parse_expression(false,false)))); goto __jakt_label_85;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_85:; __jakt_var_89.release_value(); }));
 };/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+default: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_90; {
+TRY((((*this).error(Jakt::DeprecatedString("Expected initializer"sv),((((*this).current())).span())))));
+__jakt_var_90 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))); goto __jakt_label_86;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_86:; __jakt_var_90.release_value(); }));
 };/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}/*switch end*/
+}()
+));
+TRY((((defaults).set(((declaration).name),parser::ParsedPatternDefault(declaration,value)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+if (((((*this).current())).index() == 8 /* RParen */)){
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected a ')' to end 'defaults' list"sv),((((*this).current())).span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AsteriskEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlashEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSignEqual>();
-utility::Span const& span = __jakt_match_value.value;
+((*this).skip_newlines());
+if (((((*this).current())).index() == 40 /* Pipe */)){
+((((*this).index)++));
+continue;
+}
+break;
+}
+return (patterns);
+}
+}
+
+ErrorOr<void> parser::Parser::parse_import(parser::ParsedNamespace& parent) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+if (((((*this).current())).index() == 72 /* Extern */)){
+((((*this).index)++));
+TRY((((((parent))).add_extern_import(TRY((((*this).parse_extern_import(parent))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::NotEqual>();
-utility::Span const& span = __jakt_match_value.value;
+else {
+TRY((((((parent))).add_module_import(TRY((((*this).parse_module_import())))))));
+}
+
+}
+return {};
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parser::Parser::parse_statement(bool const inside_block) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+utility::Span const start = ((((*this).current())).span());
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedStatement>, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 67: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_91; {
+((((*this).index)++));
+__jakt_var_91 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::InlineCpp>(TRY((((*this).parse_block()))),TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_87;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_87:; __jakt_var_91.release_value(); }));
 };/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DoubleEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 68: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_92; {
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedStatement> const statement = TRY((((*this).parse_statement(false))));
+__jakt_var_92 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Defer>(statement,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_88;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_88:; __jakt_var_92.release_value(); }));
 };/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThan>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 102: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_93; {
+((((*this).index)++));
+parser::ParsedBlock const block = TRY((((*this).parse_block())));
+__jakt_var_93 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::UnsafeBlock>(block,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_89;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_89:; __jakt_var_93.release_value(); }));
 };/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThanOrEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 63: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_94; {
+((((*this).index)++));
+__jakt_var_94 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Break>(start))); goto __jakt_label_90;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_90:; __jakt_var_94.release_value(); }));
 };/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThan>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 66: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_95; {
+((((*this).index)++));
+__jakt_var_95 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Continue>(start))); goto __jakt_label_91;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_91:; __jakt_var_95.release_value(); }));
 };/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThanOrEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 82: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_96; {
+((((*this).index)++));
+parser::ParsedBlock const block = TRY((((*this).parse_block())));
+__jakt_var_96 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Loop>(block,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_92;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_92:; __jakt_var_96.release_value(); }));
 };/*case end*/
-case 30: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftArithmeticShift>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 98: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_97; {
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+__jakt_var_97 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Throw>(expr,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_93;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_93:; __jakt_var_97.release_value(); }));
 };/*case end*/
-case 31: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShift>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 105: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_98; {
+((((*this).index)++));
+bool const previous_can_have_trailing_closure = ((*this).can_have_trailing_closure);
+(((*this).can_have_trailing_closure) = false);
+NonnullRefPtr<typename parser::ParsedExpression> const condition = TRY((((*this).parse_expression(false,true))));
+(((*this).can_have_trailing_closure) = previous_can_have_trailing_closure);
+parser::ParsedBlock const block = TRY((((*this).parse_block())));
+__jakt_var_98 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::While>(condition,block,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_94;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_94:; __jakt_var_98.release_value(); }));
 };/*case end*/
-case 32: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShiftEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 106: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_99; {
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(false,false))));
+if ((!(inside_block))){
+TRY((((*this).error(Jakt::DeprecatedString("‘yield’ can only be used inside a block"sv),TRY((parser::merge_spans(start,((expr)->span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 33: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShift>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+__jakt_var_99 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Yield>(expr,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_95;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_95:; __jakt_var_99.release_value(); }));
 };/*case end*/
-case 34: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightArithmeticShift>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 93: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_100; {
+((((*this).index)++));
+__jakt_var_100 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedStatement>, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 55: {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(JaktInternal::OptionalNone(),start))));
 };/*case end*/
-case 35: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShiftEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 56: {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(JaktInternal::OptionalNone(),start))));
 };/*case end*/
-case 36: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Asterisk>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 10: {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(JaktInternal::OptionalNone(),start))));
 };/*case end*/
-case 37: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Ampersand>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
+default: {
+return JaktInternal::ExplicitValue(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Return>(TRY((((*this).parse_expression(false,false)))),TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
 };/*case end*/
-case 38: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}/*switch end*/
+}()
+)); goto __jakt_label_96;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_96:; __jakt_var_100.release_value(); }));
 };/*case end*/
-case 39: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandAmpersand>();
-utility::Span const& span = __jakt_match_value.value;
+case 81: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_101; {
+bool const is_mutable = ((((*this).current())).index() == 84 /* Mut */);
+((((*this).index)++));
+JaktInternal::DynamicArray<parser::ParsedVarDecl> vars = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
+bool is_destructuring_assingment = false;
+DeprecatedString tuple_var_name = Jakt::DeprecatedString(""sv);
+parser::ParsedVarDecl tuple_var_decl = parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),is_mutable,JaktInternal::OptionalNone(),((((*this).current())).span()));
+if (((((*this).current())).index() == 7 /* LParen */)){
+(vars = ((TRY((((*this).parse_destructuring_assignment(is_mutable))))).var_decls));
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+JaktInternal::ArrayIterator<parser::ParsedVarDecl> _magic = ((vars).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedVarDecl> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 40: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Pipe>();
-utility::Span const& span = __jakt_match_value.value;
+parser::ParsedVarDecl var = (_magic_value.value());
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+(tuple_var_name += ((var).name));
+(tuple_var_name += Jakt::DeprecatedString("_"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 41: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipeEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 42: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipePipe>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 43: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Caret>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+
+(((tuple_var_decl).name) = tuple_var_name);
+(is_destructuring_assingment = true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 44: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::CaretEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+else {
+(tuple_var_decl = TRY((((*this).parse_variable_declaration(is_mutable)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 45: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dollar>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+
+NonnullRefPtr<typename parser::ParsedExpression> const init = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 16: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_102; {
+((((*this).index)++));
+__jakt_var_102 = TRY((((*this).parse_expression(false,false)))); goto __jakt_label_98;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_98:; __jakt_var_102.release_value(); }));
 };/*case end*/
-case 46: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+default: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_103; {
+TRY((((*this).error(Jakt::DeprecatedString("Expected initializer"sv),((((*this).current())).span())))));
+__jakt_var_103 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))); goto __jakt_label_99;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_99:; __jakt_var_103.release_value(); }));
 };/*case end*/
-case 47: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlash>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}/*switch end*/
+}()
+));
+NonnullRefPtr<typename parser::ParsedStatement> return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(tuple_var_decl,init,TRY((parser::merge_spans(start,((((*this).previous())).span())))))));
+if (is_destructuring_assingment){
+NonnullRefPtr<typename parser::ParsedStatement> const old_return_statement = return_statement;
+(return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::DestructuringAssignment>(vars,old_return_statement,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 48: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ExclamationPoint>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+__jakt_var_101 = return_statement; goto __jakt_label_97;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_97:; __jakt_var_101.release_value(); }));
 };/*case end*/
-case 49: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMark>();
-utility::Span const& span = __jakt_match_value.value;
+case 84: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_104; {
+bool const is_mutable = ((((*this).current())).index() == 84 /* Mut */);
+((((*this).index)++));
+JaktInternal::DynamicArray<parser::ParsedVarDecl> vars = (TRY((DynamicArray<parser::ParsedVarDecl>::create_with({}))));
+bool is_destructuring_assingment = false;
+DeprecatedString tuple_var_name = Jakt::DeprecatedString(""sv);
+parser::ParsedVarDecl tuple_var_decl = parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),is_mutable,JaktInternal::OptionalNone(),((((*this).current())).span()));
+if (((((*this).current())).index() == 7 /* LParen */)){
+(vars = ((TRY((((*this).parse_destructuring_assignment(is_mutable))))).var_decls));
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+JaktInternal::ArrayIterator<parser::ParsedVarDecl> _magic = ((vars).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedVarDecl> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 50: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMark>();
-utility::Span const& span = __jakt_match_value.value;
+parser::ParsedVarDecl var = (_magic_value.value());
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+(tuple_var_name += ((var).name));
+(tuple_var_name += Jakt::DeprecatedString("_"sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 51: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMarkEqual>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 52: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comma>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 53: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 54: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DotDot>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+
+(((tuple_var_decl).name) = tuple_var_name);
+(is_destructuring_assingment = true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 55: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Eol>();utility::Span const& span = __jakt_match_value.span;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+else {
+(tuple_var_decl = TRY((((*this).parse_variable_declaration(is_mutable)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 56: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Eof>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+
+NonnullRefPtr<typename parser::ParsedExpression> const init = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedExpression>, ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 16: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_105; {
+((((*this).index)++));
+__jakt_var_105 = TRY((((*this).parse_expression(false,false)))); goto __jakt_label_101;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_101:; __jakt_var_105.release_value(); }));
 };/*case end*/
-case 57: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::FatArrow>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+default: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedExpression>> __jakt_var_106; {
+TRY((((*this).error(Jakt::DeprecatedString("Expected initializer"sv),((((*this).current())).span())))));
+__jakt_var_106 = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Garbage>(((((*this).current())).span())))); goto __jakt_label_102;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_102:; __jakt_var_106.release_value(); }));
 };/*case end*/
-case 58: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Arrow>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}/*switch end*/
+}()
+));
+NonnullRefPtr<typename parser::ParsedStatement> return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(tuple_var_decl,init,TRY((parser::merge_spans(start,((((*this).previous())).span())))))));
+if (is_destructuring_assingment){
+NonnullRefPtr<typename parser::ParsedStatement> const old_return_statement = return_statement;
+(return_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::DestructuringAssignment>(vars,old_return_statement,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 59: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::And>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+__jakt_var_104 = return_statement; goto __jakt_label_100;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_100:; __jakt_var_104.release_value(); }));
 };/*case end*/
-case 60: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Anon>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 77: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_if_statement()))));
 };/*case end*/
-case 61: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::As>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 74: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_for_statement()))));
 };/*case end*/
-case 62: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Boxed>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+case 9: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_107; {
+parser::ParsedBlock const block = TRY((((*this).parse_block())));
+__jakt_var_107 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(block,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_103;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_103:; __jakt_var_107.release_value(); }));
 };/*case end*/
-case 63: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Break>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 107: {
+return JaktInternal::ExplicitValue(TRY((((*this).parse_guard_statement()))));
 };/*case end*/
-case 64: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Catch>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+default: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename parser::ParsedStatement>> __jakt_var_108; {
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_expression(true,false))));
+__jakt_var_108 = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Expression>(expr,TRY((parser::merge_spans(start,((((*this).previous())).span()))))))); goto __jakt_label_104;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_104:; __jakt_var_108.release_value(); }));
 };/*case end*/
-case 65: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Class>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}/*switch end*/
+}()
+)));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 66: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Continue>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 67: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Cpp>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<parser::ParsedField> parser::Parser::parse_field(parser::Visibility const visibility) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+parser::ParsedVarDecl const parsed_variable_declaration = TRY((((*this).parse_variable_declaration(true))));
+if (((((parsed_variable_declaration).parsed_type))->index() == 13 /* Empty */)){
+TRY((((*this).error(Jakt::DeprecatedString("Field missing type"sv),((parsed_variable_declaration).span)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 68: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Defer>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_value = JaktInternal::OptionalNone();
+if (((((*this).peek(static_cast<size_t>(0ULL)))).index() == 16 /* Equal */)){
+((((*this).index)++));
+(default_value = TRY((((*this).parse_expression(false,false)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 69: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Destructor>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+return (parser::ParsedField(parsed_variable_declaration,visibility,default_value));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 70: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Else>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 71: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Enum>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<DeprecatedString> parser::Parser::parse_argument_label() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+if ((((((*this).peek(static_cast<size_t>(1ULL)))).index() == 5 /* Colon */) && ((((*this).current())).index() == 3 /* Identifier */))){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(2ULL));});
+return (name);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 72: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Extern>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+return (Jakt::DeprecatedString(""sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 73: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 74: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::For>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_ampersand() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+utility::Span const start = ((((*this).current())).span());
+((((*this).index)++));
+if (((((*this).current())).index() == 91 /* Raw */)){
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::RawAddress() } ,TRY((parser::merge_spans(start,((expr)->span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 75: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Fn>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+if (((((*this).current())).index() == 84 /* Mut */)){
+((((*this).index)++));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::MutableReference() } ,TRY((parser::merge_spans(start,((expr)->span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 76: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comptime>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+NonnullRefPtr<typename parser::ParsedExpression> const expr = TRY((((*this).parse_operand())));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::Reference() } ,TRY((parser::merge_spans(start,((expr)->span()))))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 77: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::If>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 78: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Import>();
-utility::Span const& span = __jakt_match_value.value;
+
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>> parser::Parser::parse_include_action() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 79: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::In>();
-utility::Span const& span = __jakt_match_value.value;
+((*this).skip_newlines());
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>>>{
+auto __jakt_enum_value = (name);
+if (__jakt_enum_value == Jakt::DeprecatedString("define"sv)) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+((((*this).index)++));
+((*this).skip_newlines());
+if (((((*this).current())).index() == 9 /* LCurly */)){
+((((*this).index)++));
+((*this).skip_newlines());
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 80: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Is>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected '{' to start define action"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
 }
-return JaktInternal::ExplicitValue<void>();
+
+JaktInternal::DynamicArray<parser::IncludeAction> defines = (TRY((DynamicArray<parser::IncludeAction>::create_with({}))));
+for (;;){
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const span = ((((*this).current())).span());
+((((*this).index)++));
+((*this).skip_newlines());
+if (((((*this).current())).index() == 16 /* Equal */)){
+((((*this).index)++));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected '=' to assign value to defined symbols"sv),((((*this).current())).span())))));
+continue;
+}
+
+DeprecatedString const value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();DeprecatedString const& quote = __jakt_match_value.quote;
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_109; {
+((((*this).index)++));
+__jakt_var_109 = quote; goto __jakt_label_105;
+
+}
+__jakt_label_105:; __jakt_var_109.release_value(); }));
 };/*case end*/
-case 81: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Let>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+default: {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_110; {
+TRY((((*this).error(Jakt::DeprecatedString("Expected quoted string to assign value to defined symbols"sv),((((*this).current())).span())))));
+__jakt_var_110 = Jakt::DeprecatedString(""sv); goto __jakt_label_106;
+
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_106:; __jakt_var_110.release_value(); }));
 };/*case end*/
-case 82: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Loop>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+}/*switch end*/
+}()
+));
+TRY((((defines).push( parser::IncludeAction { typename parser::IncludeAction::Define(name,span,value) } ))));
+((*this).skip_newlines());
+if (((((*this).current())).index() == 52 /* Comma */)){
+((((*this).index)++));
+((*this).skip_newlines());
+}
+}
+else {
+break;
+}
+
+}
+if (((((*this).current())).index() == 10 /* RCurly */)){
+((((*this).index)++));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected '}' to end define action"sv),((((*this).current())).span())))));
+}
+
+return (static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>>(defines));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 83: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Match>();
-utility::Span const& span = __jakt_match_value.value;
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("undefine"sv)) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+((((*this).index)++));
+((*this).skip_newlines());
+if (((((*this).current())).index() == 9 /* LCurly */)){
+((((*this).index)++));
+((*this).skip_newlines());
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected '{' to start undefine include action"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
+}
+
+JaktInternal::DynamicArray<parser::IncludeAction> defines = (TRY((DynamicArray<parser::IncludeAction>::create_with({}))));
+for (;;){
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const span = ((((*this).current())).span());
+((((*this).index)++));
+TRY((((defines).push( parser::IncludeAction { typename parser::IncludeAction::Undefine(name,span) } ))));
+((*this).skip_newlines());
+if (((((*this).current())).index() == 52 /* Comma */)){
+((((*this).index)++));
+((*this).skip_newlines());
+}
+}
+else {
+break;
+}
+
+}
+if (((((*this).current())).index() == 10 /* RCurly */)){
+((((*this).index)++));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected '}' to end undefine action"sv),((((*this).current())).span())))));
+}
+
+return (static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>>(defines));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 84: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Mut>();
-utility::Span const& span = __jakt_match_value.value;
+}
+else {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 85: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Namespace>();
-utility::Span const& span = __jakt_match_value.value;
-{
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 86: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
-utility::Span const& span = __jakt_match_value.value;
+}()))
+;
+TRY((((*this).error(Jakt::DeprecatedString("Expected 'define' or 'undefine' in include action"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected 'define' or 'undefine' in include action"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
+}
+
+}
+}
+
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_try_block() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+utility::Span const start_span = ((((*this).current())).span());
+NonnullRefPtr<typename parser::ParsedStatement> const stmt = TRY((((*this).parse_statement(false))));
+DeprecatedString error_name = Jakt::DeprecatedString(""sv);
+utility::Span error_span = ((((*this).current())).span());
+if (((((*this).current())).index() == 64 /* Catch */)){
+((((*this).index)++));
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+(error_span = ((((*this).current())).span()));
+(error_name = name);
+((((*this).index)++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 87: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Or>();
-utility::Span const& span = __jakt_match_value.value;
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected ‘catch’"sv),((((*this).current())).span())))));
+}
+
+parser::ParsedBlock const catch_block = TRY((((*this).parse_block())));
+return (TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::TryBlock>(stmt,error_name,error_span,catch_block,TRY((parser::merge_spans(start_span,((((*this).previous())).span()))))))));
+}
+}
+
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedGenericParameter>> parser::Parser::parse_generic_parameters() {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+if ((!(((((*this).current())).index() == 28 /* LessThan */)))){
+return ((TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 88: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Override>();
-utility::Span const& span = __jakt_match_value.value;
+((((*this).index)++));
+JaktInternal::DynamicArray<parser::ParsedGenericParameter> generic_parameters = (TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({}))));
+((*this).skip_newlines());
+bool saw_ending_bracket = false;
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::DynamicArray<parser::ParsedGenericParameter>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> requires_list = JaktInternal::OptionalNone();
+((((*this).index)++));
+if (((((*this).current())).index() == 109 /* Requires */)){
+((((*this).index)++));
+(requires_list = TRY((((*this).parse_trait_list()))));
+}
+TRY((((generic_parameters).push(parser::ParsedGenericParameter(name,span,requires_list)))));
+if ((((((*this).current())).index() == 52 /* Comma */) || ((((*this).current())).index() == 55 /* Eol */))){
+((((*this).index)++));
+}
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 89: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
-utility::Span const& span = __jakt_match_value.value;
+case 26: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+((((*this).index)++));
+(saw_ending_bracket = true);
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 90: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
-utility::Span const& span = __jakt_match_value.value;
+case 33: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).inject_token( lexer::Token { typename lexer::Token::GreaterThan(((((*this).current())).span())) } ))));
+({auto& _jakt_ref = ((*this).index);_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+(saw_ending_bracket = true);
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 91: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Raw>();
-utility::Span const& span = __jakt_match_value.value;
+case 111: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected `>` to end the generic parameters"sv),((((*this).current())).span())))));
+return (generic_parameters);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 92: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
-utility::Span const& span = __jakt_match_value.value;
+default: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected generic parameter name"sv),((((*this).current())).span())))));
+return (generic_parameters);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 93: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Return>();
-utility::Span const& span = __jakt_match_value.value;
+}/*switch end*/
+}()
+));
+}
+if ((!(saw_ending_bracket))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected `>` to end the generic parameters"sv),((((*this).current())).span())))));
+return (generic_parameters);
+}
+return (generic_parameters);
+}
+}
+
+ErrorOr<parser::ParsedRecord> parser::Parser::parse_struct(parser::DefinitionLinkage const definition_linkage) {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+parser::ParsedRecord parsed_struct = parser::ParsedRecord(Jakt::DeprecatedString(""sv),((*this).empty_span()),(TRY((DynamicArray<parser::ParsedGenericParameter>::create_with({})))),definition_linkage,JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::ParsedMethod>::create_with({})))), parser::RecordType { typename parser::RecordType::Garbage() } ,JaktInternal::OptionalNone());
+if (((((*this).current())).index() == 96 /* Struct */)){
+((((*this).index)++));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected `struct` keyword"sv),((((*this).current())).span())))));
+return (parsed_struct);
+}
+
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct definition, expected name"sv),((((*this).current())).span())))));
+return (parsed_struct);
+}
+if (((((*this).current())).index() == 3 /* Identifier */)){
+DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
+utility::Span const span = ((((*this).current())).get<lexer::Token::Identifier>()).span;
+((((*this).index)++));
+(((parsed_struct).name) = name);
+(((parsed_struct).name_span) = span);
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct definition, expected name"sv),((((*this).current())).span())))));
+}
+
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct definition, expected generic parameters or body"sv),((((*this).current())).span())))));
+return (parsed_struct);
+}
+(((parsed_struct).generic_parameters) = TRY((((*this).parse_generic_parameters()))));
+if (((((*this).current())).index() == 108 /* Implements */)){
+((((*this).index)++));
+(((parsed_struct).implements_list) = TRY((((*this).parse_trait_list()))));
+}
+((*this).skip_newlines());
+if (((*this).eof())){
+TRY((((*this).error(Jakt::DeprecatedString("Incomplete struct definition, expected body"sv),((((*this).current())).span())))));
+return (parsed_struct);
+}
+JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>> const fields_methods_ = TRY((((*this).parse_struct_class_body(definition_linkage, parser::Visibility { typename parser::Visibility::Public() } ,false))));
+JaktInternal::DynamicArray<parser::ParsedField> const fields = ((fields_methods_).template get<0>());
+JaktInternal::DynamicArray<parser::ParsedMethod> const methods = ((fields_methods_).template get<1>());
+
+(((parsed_struct).methods) = methods);
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const super_type = JaktInternal::OptionalNone();
+(((parsed_struct).record_type) =  parser::RecordType { typename parser::RecordType::Struct(fields,super_type) } );
+return (parsed_struct);
+}
+}
+
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>>> parser::Parser::parse_trait_list() {
+{
+if (((((*this).current())).index() == 7 /* LParen */)){
+((((*this).index)++));
+JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> result = (TRY((DynamicArray<parser::ParsedNameWithGenericParameters>::create_with({}))));
+while ((!(((*this).eof())))){
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>>>>{
+auto&& __jakt_match_variant = ((*this).current());
+switch(__jakt_match_variant.index()) {
+case 55: {
+{
+((((*this).index)++));
+return JaktInternal::LoopContinue{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 94: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
-utility::Span const& span = __jakt_match_value.value;
+case 52: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+((((*this).index)++));
+return JaktInternal::LoopContinue{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 95: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
+case 56: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Eof>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected ')' to close the trait list"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 96: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Struct>();
-utility::Span const& span = __jakt_match_value.value;
+case 8: {
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+((((*this).index)++));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 97: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
-utility::Span const& span = __jakt_match_value.value;
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Identifier>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+parser::ParsedNameWithGenericParameters parsed_name = parser::ParsedNameWithGenericParameters(name,span,(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({})))));
+((((*this).index)++));
+(((parsed_name).generic_parameters) = TRY((((*this).parse_type_parameter_list()))));
+TRY((((result).push(parsed_name))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 98: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throw>();
-utility::Span const& span = __jakt_match_value.value;
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 99: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throws>();
-utility::Span const& span = __jakt_match_value.value;
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::QuotedString>();utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 100: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
-utility::Span const& span = __jakt_match_value.value;
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Number>();utility::Span const& span = __jakt_match_value.span;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 101: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Semicolon>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 102: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Unsafe>();
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Colon>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 103: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Virtual>();
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ColonColon>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 104: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Weak>();
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LParen>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 105: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::While>();
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LCurly>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 106: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Yield>();
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RCurly>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 107: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Guard>();
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LSquare>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 108: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Implements>();
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RSquare>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 109: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Requires>();
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSign>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 110: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Trait>();
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Plus>();
 utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 111: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Garbage>();utility::Span const& span = __jakt_match_value.span;
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Minus>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).error(Jakt::DeprecatedString("Expected alias name"sv),span))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-}
-return (alias);
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Equal>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-lexer::Token parser::Parser::current() const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PlusPlus>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return (((*this).peek(static_cast<size_t>(0ULL))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parser::Parser::parse_expression(bool const allow_assignments,bool const allow_newlines) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::MinusMinus>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> expr_stack = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>>::create_with({}))));
-i64 last_precedence = static_cast<i64>(1000000LL);
-NonnullRefPtr<typename parser::ParsedExpression> const lhs = TRY((((*this).parse_operand())));
-TRY((((expr_stack).push(lhs))));
-for (;;){
-if (allow_newlines){
-if ((((*this).eof()) || ((((*this).current())).index() == 9 /* LCurly */))){
-break;
-}
-((*this).skip_newlines());
-}
-else {
-if (((*this).eol())){
-break;
-}
-}
-
-NonnullRefPtr<typename parser::ParsedExpression> const parsed_operator = TRY((((*this).parse_operator(allow_assignments))));
-if (((parsed_operator)->index() == 29 /* Garbage */)){
-break;
-}
-i64 const precedence = ((parsed_operator)->precedence());
-((*this).skip_newlines());
-NonnullRefPtr<typename parser::ParsedExpression> const rhs = TRY((((*this).parse_operand())));
-while (((precedence <= last_precedence) && (((expr_stack).size()) > static_cast<size_t>(1ULL)))){
-NonnullRefPtr<typename parser::ParsedExpression> const rhs = (((expr_stack).pop()).value());
-NonnullRefPtr<typename parser::ParsedExpression> const op = (((expr_stack).pop()).value());
-(last_precedence = ((op)->precedence()));
-if ((last_precedence < precedence)){
-TRY((((expr_stack).push(op))));
-TRY((((expr_stack).push(rhs))));
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-NonnullRefPtr<typename parser::ParsedExpression> const lhs = (((expr_stack).pop()).value());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = *op;
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& op = __jakt_match_value.op;
-utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AsteriskEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const new_span = TRY((parser::merge_spans(((lhs)->span()),((rhs)->span()))));
-TRY((((expr_stack).push(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::BinaryOp>(lhs,op,rhs,new_span)))))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlashEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("operator is not an operator"sv)))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-}
-TRY((((expr_stack).push(parsed_operator))));
-TRY((((expr_stack).push(rhs))));
-(last_precedence = precedence);
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PercentSignEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-while ((((expr_stack).size()) > static_cast<size_t>(1ULL))){
-NonnullRefPtr<typename parser::ParsedExpression> const rhs = (((expr_stack).pop()).value());
-NonnullRefPtr<typename parser::ParsedExpression> const parsed_operator = (((expr_stack).pop()).value());
-NonnullRefPtr<typename parser::ParsedExpression> const lhs = (((expr_stack).pop()).value());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>>>{
-auto&& __jakt_match_variant = *parsed_operator;
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& op = __jakt_match_value.op;
-utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::NotEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const new_span = TRY((parser::merge_spans(((lhs)->span()),((rhs)->span()))));
-TRY((((expr_stack).push(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::BinaryOp>(lhs,op,rhs,new_span)))))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DoubleEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("operator is not an operator"sv)))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThan>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-return (((expr_stack)[static_cast<i64>(0LL)]));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::GreaterThanOrEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThan>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-lexer::Token parser::Parser::peek(size_t const steps) const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LessThanOrEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((((*this).eof()) || ((JaktInternal::checked_add<size_t>(steps,((*this).index))) >= ((((*this).tokens)).size())))){
-return ((((((*this).tokens)).last()).value()));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-return (((((*this).tokens))[(JaktInternal::checked_add<size_t>(((*this).index),steps))]));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 30: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftArithmeticShift>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 31: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShift>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parser::Parser::parse_type_shorthand() {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 32: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::LeftShiftEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, ErrorOr<NonnullRefPtr<typename parser::ParsedType>>>{
-auto&& __jakt_match_variant = ((*this).current());
-switch(__jakt_match_variant.index()) {
-case 11: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_type_shorthand_array_or_dictionary()))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_type_shorthand_set()))));
+case 33: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShift>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(TRY((((*this).parse_type_shorthand_tuple()))));
+case 34: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightArithmeticShift>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())));
+case 35: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::RightShiftEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 36: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Asterisk>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 37: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Ampersand>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-utility::Span parser::Parser::empty_span() const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 38: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return (((*this).span(static_cast<size_t>(0ULL),static_cast<size_t>(0ULL))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 39: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::AmpersandAmpersand>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<parser::ParsedVarDecl> parser::Parser::parse_variable_declaration(bool const is_mutable) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 40: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Pipe>();
+utility::Span const& span = __jakt_match_value.value;
 {
-utility::Span const span = ((((*this).current())).span());
-if (((((*this).current())).index() == 3 /* Identifier */)){
-DeprecatedString const name = ((((*this).current())).get<lexer::Token::Identifier>()).name;
-((((*this).index)++));
-if (((((*this).current())).index() == 5 /* Colon */)){
-((((*this).index)++));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-else {
-return (parser::ParsedVarDecl(name,TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),is_mutable,span,span));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 41: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipeEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-NonnullRefPtr<typename parser::ParsedType> const parsed_type = TRY((((*this).parse_typename())));
-if ((is_mutable && (((parsed_type)->index() == 8 /* Reference */) || ((parsed_type)->index() == 9 /* MutableReference */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Reference parameter can not be mutable"sv),span))));
-}
-return (parser::ParsedVarDecl(name,parsed_type,is_mutable,JaktInternal::OptionalNone(),span));
-}
-else {
-return (parser::ParsedVarDecl(Jakt::DeprecatedString(""sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),false,JaktInternal::OptionalNone(),span));
-}
-
-}
-}
-
-ErrorOr<DeprecatedString> parser::ParsedCall::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedCall("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespace_: {}, ", namespace_));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("args: {}, ", args));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_args: {}", type_args));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedCall::ParsedCall(JaktInternal::DynamicArray<DeprecatedString> a_namespace_, DeprecatedString a_name, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> a_args, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> a_type_args) :namespace_(move(a_namespace_)), name(move(a_name)), args(move(a_args)), type_args(move(a_type_args)){}
-
-bool parser::ParsedCall::equals(parser::ParsedCall const rhs_parsed_call) const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 42: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::PipePipe>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((((*this).name) != ((rhs_parsed_call).name))){
-return (false);
-}
-if ((((((*this).args)).size()) != ((((rhs_parsed_call).args)).size()))){
-return (false);
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 43: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Caret>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((*this).args)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-size_t i = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 44: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::CaretEqual>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const lhs_str___lhs_expr_ = ((((*this).args))[i]);
-DeprecatedString const lhs_str = ((lhs_str___lhs_expr_).template get<0>());
-utility::Span const _ = ((lhs_str___lhs_expr_).template get<1>());
-NonnullRefPtr<typename parser::ParsedExpression> const lhs_expr = ((lhs_str___lhs_expr_).template get<2>());
-
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const rhs_str____rhs_expr_ = ((((rhs_parsed_call).args))[i]);
-DeprecatedString const rhs_str = ((rhs_str____rhs_expr_).template get<0>());
-utility::Span const __ = ((rhs_str____rhs_expr_).template get<1>());
-NonnullRefPtr<typename parser::ParsedExpression> const rhs_expr = ((rhs_str____rhs_expr_).template get<2>());
-
-if (((lhs_str != rhs_str) || (!(((lhs_expr)->equals(rhs_expr)))))){
-return (false);
-}
-}
-
-}
-}
-
-return (true);
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 45: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dollar>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<DeprecatedString> parser::ParsedNamespace::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedNamespace("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: {}, ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("functions: {}, ", functions));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("records: {}, ", records));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_trait_implementations: {}, ", external_trait_implementations));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespaces: {}, ", namespaces));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("aliases: {}, ", aliases));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module_imports: {}, ", module_imports));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("extern_imports: {}, ", extern_imports));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("import_path_if_extern: {}, ", import_path_if_extern));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generating_import_extern_before_include: {}, ", generating_import_extern_before_include));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generating_import_extern_after_include: {}", generating_import_extern_after_include));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 46: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Tilde>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<void> parser::ParsedNamespace::add_child_namespace(parser::ParsedNamespace const namespace_) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 47: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ForwardSlash>();
+utility::Span const& span = __jakt_match_value.value;
 {
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 48: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::ExclamationPoint>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedNamespace> _magic = ((((*this).namespaces)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedNamespace> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-parser::ParsedNamespace child_namespace = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 49: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMark>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((child_namespace).is_equivalent_to(namespace_))){
-TRY((((child_namespace).merge_with(namespace_))));
-return {};
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 50: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMark>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 51: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::QuestionMarkQuestionMarkEqual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 53: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Dot>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-TRY((((((*this).namespaces)).push(namespace_))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 54: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::DotDot>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-return {};
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 57: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::FatArrow>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-parser::ParsedNamespace::ParsedNamespace(JaktInternal::Optional<DeprecatedString> a_name, JaktInternal::Optional<utility::Span> a_name_span, JaktInternal::DynamicArray<parser::ParsedFunction> a_functions, JaktInternal::DynamicArray<parser::ParsedRecord> a_records, JaktInternal::DynamicArray<parser::ParsedTrait> a_traits, JaktInternal::DynamicArray<parser::ParsedExternalTraitImplementation> a_external_trait_implementations, JaktInternal::DynamicArray<parser::ParsedNamespace> a_namespaces, JaktInternal::DynamicArray<parser::ParsedAlias> a_aliases, JaktInternal::DynamicArray<parser::ParsedModuleImport> a_module_imports, JaktInternal::DynamicArray<parser::ParsedExternImport> a_extern_imports, JaktInternal::Optional<DeprecatedString> a_import_path_if_extern, JaktInternal::DynamicArray<parser::IncludeAction> a_generating_import_extern_before_include, JaktInternal::DynamicArray<parser::IncludeAction> a_generating_import_extern_after_include) :name(move(a_name)), name_span(move(a_name_span)), functions(move(a_functions)), records(move(a_records)), traits(move(a_traits)), external_trait_implementations(move(a_external_trait_implementations)), namespaces(move(a_namespaces)), aliases(move(a_aliases)), module_imports(move(a_module_imports)), extern_imports(move(a_extern_imports)), import_path_if_extern(move(a_import_path_if_extern)), generating_import_extern_before_include(move(a_generating_import_extern_before_include)), generating_import_extern_after_include(move(a_generating_import_extern_after_include)){}
-
-bool parser::ParsedNamespace::is_equivalent_to(parser::ParsedNamespace const other) const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 58: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Arrow>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return (((((*this).name) == ((other).name)) && (((*this).import_path_if_extern) == ((other).import_path_if_extern))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 59: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::And>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<void> parser::ParsedNamespace::add_extern_import(parser::ParsedExternImport const import_) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 60: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Anon>();
+utility::Span const& span = __jakt_match_value.value;
 {
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 61: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::As>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedExternImport> _magic = ((((*this).extern_imports)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedExternImport> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-parser::ParsedExternImport extern_import = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 62: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Boxed>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (TRY((((extern_import).is_equivalent_to(import_))))){
-TRY((((((extern_import).assigned_namespace)).merge_with(((import_).assigned_namespace)))));
-TRY((((((extern_import).before_include)).push_values(((((import_).before_include)))))));
-TRY((((((extern_import).after_include)).push_values(((((import_).after_include)))))));
-return {};
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 63: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Break>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 64: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Catch>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-}
-
-TRY((((((*this).extern_imports)).push(import_))));
-}
-return {};
-}
-
-ErrorOr<void> parser::ParsedNamespace::add_alias(parser::ParsedAlias const alias) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 65: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Class>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((((*this).aliases)).push(alias))));
-}
-return {};
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<void> parser::ParsedNamespace::merge_with(parser::ParsedNamespace const namespace_) {
-{
-TRY((((((*this).functions)).push_values(((((namespace_).functions)))))));
-TRY((((((*this).records)).push_values(((((namespace_).records)))))));
-TRY((((((*this).module_imports)).add_capacity(((((namespace_).module_imports)).size())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 66: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Continue>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedModuleImport> _magic = ((((namespace_).module_imports)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedModuleImport> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-parser::ParsedModuleImport import_ = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 67: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Cpp>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).add_module_import(import_))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 68: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Defer>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 69: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Destructor>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-TRY((((((*this).extern_imports)).add_capacity(((((namespace_).extern_imports)).size())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 70: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Else>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedExternImport> _magic = ((((namespace_).extern_imports)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedExternImport> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-parser::ParsedExternImport import_ = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 71: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Enum>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).add_extern_import(import_))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 72: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Extern>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 73: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::False>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 74: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::For>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedNamespace> _magic = ((((namespace_).namespaces)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedNamespace> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-parser::ParsedNamespace child_namespace = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 75: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Fn>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).add_child_namespace(child_namespace))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 76: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Comptime>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 77: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::If>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 78: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Import>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedAlias> _magic = ((((namespace_).aliases)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedAlias> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-parser::ParsedAlias alias = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 79: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::In>();
+utility::Span const& span = __jakt_match_value.value;
 {
-TRY((((*this).add_alias(alias))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 80: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Is>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 81: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Let>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 82: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Loop>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-return {};
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 83: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Match>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<void> parser::ParsedNamespace::add_module_import(parser::ParsedModuleImport const import_) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 84: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Mut>();
+utility::Span const& span = __jakt_match_value.value;
 {
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 85: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Namespace>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedModuleImport> _magic = ((((*this).module_imports)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedModuleImport> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-parser::ParsedModuleImport module_import = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 86: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Not>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if (((module_import).is_equivalent_to(import_))){
-TRY((((module_import).merge_import_list(((import_).import_list)))));
-return {};
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 87: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Or>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 88: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Override>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 89: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Private>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-TRY((((((*this).module_imports)).push(import_))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 90: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Public>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-return {};
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 91: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Raw>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<DeprecatedString> parser::ParsedName::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedName("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 92: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Reflect>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedName::ParsedName(DeprecatedString a_name, utility::Span a_span) :name(move(a_name)), span(move(a_span)){}
-
-ErrorOr<DeprecatedString> parser::ParsedAlias::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedAlias("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("alias_name: {}, ", alias_name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("target: {}", target));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 93: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Return>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedAlias::ParsedAlias(JaktInternal::Optional<parser::ParsedName> a_alias_name, JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> a_target) :alias_name(move(a_alias_name)), target(move(a_target)){}
-
-ErrorOr<DeprecatedString> parser::ParsedVarDecl::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedVarDecl("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parsed_type: {}, ", parsed_type));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_mutable: {}, ", is_mutable));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("inlay_span: {}, ", inlay_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 94: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Restricted>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedVarDecl::ParsedVarDecl(DeprecatedString a_name, NonnullRefPtr<typename parser::ParsedType> a_parsed_type, bool a_is_mutable, JaktInternal::Optional<utility::Span> a_inlay_span, utility::Span a_span) :name(move(a_name)), parsed_type(move(a_parsed_type)), is_mutable(move(a_is_mutable)), inlay_span(move(a_inlay_span)), span(move(a_span)){}
-
-bool parser::ParsedVarDecl::equals(parser::ParsedVarDecl const rhs_var_decl) const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 95: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Sizeof>();
+utility::Span const& span = __jakt_match_value.value;
 {
-return (((((*this).name) == ((rhs_var_decl).name)) && (((*this).is_mutable) == ((rhs_var_decl).is_mutable))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 96: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Struct>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-ErrorOr<DeprecatedString> parser::ParsedMethod::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedMethod("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parsed_function: {}, ", parsed_function));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("visibility: {}, ", visibility));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_virtual: {}, ", is_virtual));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_override: {}", is_override));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 97: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::This>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-parser::ParsedMethod::ParsedMethod(parser::ParsedFunction a_parsed_function, parser::Visibility a_visibility, bool a_is_virtual, bool a_is_override) :parsed_function(move(a_parsed_function)), visibility(move(a_visibility)), is_virtual(move(a_is_virtual)), is_override(move(a_is_override)){}
-
-ErrorOr<DeprecatedString> parser::ParsedMatchCase::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedMatchCase("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("patterns: {}, ", patterns));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("marker_span: {}, ", marker_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("body: {}", body));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 98: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throw>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-bool parser::ParsedMatchCase::has_equal_pattern(parser::ParsedMatchCase const rhs_match_case) const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 99: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Throws>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((((((*this).patterns)).size()) == ((((rhs_match_case).patterns)).size()))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 100: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::True>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((((*this).patterns)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-size_t i = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 101: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Try>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((!(((((((*this).patterns))[i])).is_equal_pattern(((((rhs_match_case).patterns))[i])))))){
-return (false);
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 102: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Unsafe>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 103: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Virtual>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 104: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Weak>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-return (true);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 105: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::While>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-else {
-return (false);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 106: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Yield>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 107: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Guard>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 108: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Implements>();
+utility::Span const& span = __jakt_match_value.value;
+{
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-
-bool parser::ParsedMatchCase::equals(parser::ParsedMatchCase const rhs_match_case) const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 109: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Requires>();
+utility::Span const& span = __jakt_match_value.value;
 {
-if ((((((*this).patterns)).size()) == ((((rhs_match_case).patterns)).size()))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 110: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename lexer::Token::Trait>();
+utility::Span const& span = __jakt_match_value.value;
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((((*this).patterns)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
-size_t i = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 111: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<lexer::Token::Garbage>();utility::Span const& span = __jakt_match_value.span;
 {
-if ((!(((((((*this).patterns))[i])).equals(((((rhs_match_case).patterns))[i])))))){
-return (false);
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait name"sv),span))));
+return JaktInternal::LoopBreak{};
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
 }
-
+if (((result).is_empty())){
+TRY((((*this).error(Jakt::DeprecatedString("Expected trait list to have at least one trait inside it"sv),((((*this).previous())).span())))));
+return (JaktInternal::OptionalNone());
 }
+else {
+return (static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>>>(result));
 }
 
-return (((((*this).body)).equals(((rhs_match_case).body))));
 }
 else {
-return (false);
+TRY((((*this).error(Jakt::DeprecatedString("Expected '(' to start the trait list"sv),((((*this).current())).span())))));
+return (JaktInternal::OptionalNone());
 }
 
 }
 }
 
-parser::ParsedMatchCase::ParsedMatchCase(JaktInternal::DynamicArray<parser::ParsedMatchPattern> a_patterns, utility::Span a_marker_span, parser::ParsedMatchBody a_body) :patterns(move(a_patterns)), marker_span(move(a_marker_span)), body(move(a_body)){}
+ErrorOr<DeprecatedString> parser::EnumVariantPatternArgument::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("EnumVariantPatternArgument("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: {}, ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("binding: \"{}\", ", binding));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_reference: {}, ", is_reference));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_mutable: {}", is_mutable));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::EnumVariantPatternArgument::EnumVariantPatternArgument(JaktInternal::Optional<DeprecatedString> a_name, DeprecatedString a_binding, utility::Span a_span, bool a_is_reference, bool a_is_mutable) :name(move(a_name)), binding(move(a_binding)), span(move(a_span)), is_reference(move(a_is_reference)), is_mutable(move(a_is_mutable)){}
+
+bool parser::EnumVariantPatternArgument::equals(parser::EnumVariantPatternArgument const rhs_variant_pattern_argument) const {
+{
+if ((((*this).binding) != ((rhs_variant_pattern_argument).binding))){
+return (false);
+}
+if ((((((*this).name)).has_value()) && ((((rhs_variant_pattern_argument).name)).has_value()))){
+return (((((*this).name).value()) == (((rhs_variant_pattern_argument).name).value())));
+}
+if ((((*this).is_reference) != ((rhs_variant_pattern_argument).is_reference))){
+return (false);
+}
+if ((((*this).is_mutable) != ((rhs_variant_pattern_argument).is_mutable))){
+return (false);
+}
+return (((!(((((*this).name)).has_value()))) && (!(((((rhs_variant_pattern_argument).name)).has_value())))));
+}
+}
+
+ErrorOr<DeprecatedString> parser::ParsedPatternDefault::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedPatternDefault("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("variable: {}, ", variable));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("value: {}", value));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedPatternDefault::ParsedPatternDefault(parser::ParsedVarDecl a_variable, NonnullRefPtr<typename parser::ParsedExpression> a_value) :variable(move(a_variable)), value(move(a_value)){}
 
 ErrorOr<DeprecatedString> parser::ParsedParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedParameter("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
@@ -10760,6 +10633,8 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedParameter::ParsedParameter(bool a_requires_label, parser::ParsedVariable a_variable, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_argument, utility::Span a_span) :requires_label(move(a_requires_label)), variable(move(a_variable)), default_argument(move(a_default_argument)), span(move(a_span)){}
+
 bool parser::ParsedParameter::equals(parser::ParsedParameter const rhs_param) const {
 {
 if (((((*this).requires_label) == ((rhs_param).requires_label)) && ((((*this).variable)).equals(((rhs_param).variable))))){
@@ -10775,8 +10650,6 @@ return (false);
 }
 }
 
-parser::ParsedParameter::ParsedParameter(bool a_requires_label, parser::ParsedVariable a_variable, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_argument, utility::Span a_span) :requires_label(move(a_requires_label)), variable(move(a_variable)), default_argument(move(a_default_argument)), span(move(a_span)){}
-
 ErrorOr<DeprecatedString> parser::ValueEnumVariant::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ValueEnumVariant("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
@@ -10786,439 +10659,605 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(builder.append(")"sv));return builder.to_string(); }
 parser::ValueEnumVariant::ValueEnumVariant(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_value) :name(move(a_name)), span(move(a_span)), value(move(a_value)){}
 
-ErrorOr<DeprecatedString> parser::VisibilityRestriction::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("VisibilityRestriction("sv));{
+ErrorOr<DeprecatedString> parser::ParsedRecord::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedRecord("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespace_: {}, ", namespace_));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\"", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_parameters: {}, ", generic_parameters));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("definition_linkage: {}, ", definition_linkage));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("implements_list: {}, ", implements_list));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("methods: {}, ", methods));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("record_type: {}, ", record_type));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}", external_name));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-parser::VisibilityRestriction::VisibilityRestriction(JaktInternal::DynamicArray<DeprecatedString> a_namespace_, DeprecatedString a_name) :namespace_(move(a_namespace_)), name(move(a_name)){}
+parser::ParsedRecord::ParsedRecord(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<parser::ParsedGenericParameter> a_generic_parameters, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> a_implements_list, JaktInternal::DynamicArray<parser::ParsedMethod> a_methods, parser::RecordType a_record_type, JaktInternal::Optional<DeprecatedString> a_external_name) :name(move(a_name)), name_span(move(a_name_span)), generic_parameters(move(a_generic_parameters)), definition_linkage(move(a_definition_linkage)), implements_list(move(a_implements_list)), methods(move(a_methods)), record_type(move(a_record_type)), external_name(move(a_external_name)){}
 
-ErrorOr<DeprecatedString> parser::IncludeAction::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Define */: {
-TRY(builder.append("IncludeAction::Define"sv));
-[[maybe_unused]] auto const& that = this->template get<IncludeAction::Define>();
-TRY(builder.append("("sv));
-{
+ErrorOr<DeprecatedString> parser::ParsedAttribute::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedAttribute("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("value: \"{}\"", that.value));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("assigned_value: {}, ", assigned_value));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("arguments: {}", arguments));
 }
-TRY(builder.append(")"sv));
-break;}
-case 1 /* Undefine */: {
-TRY(builder.append("IncludeAction::Undefine"sv));
-[[maybe_unused]] auto const& that = this->template get<IncludeAction::Undefine>();
-TRY(builder.append("("sv));
-{
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedAttribute::ParsedAttribute(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<DeprecatedString> a_assigned_value, JaktInternal::DynamicArray<parser::ParsedAttributeArgument> a_arguments) :name(move(a_name)), span(move(a_span)), assigned_value(move(a_assigned_value)), arguments(move(a_arguments)){}
+
+ErrorOr<DeprecatedString> parser::ParsedBlock::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ParsedBlock("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("stmts: {}", stmts));
 }
-TRY(builder.append(")"sv));
-break;}
+TRY(builder.append(")"sv));return builder.to_string(); }
+parser::ParsedBlock::ParsedBlock(JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> a_stmts) :stmts(move(a_stmts)){}
+
+JaktInternal::Optional<utility::Span> parser::ParsedBlock::find_yield_span() const {
+{
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((*this).stmts)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return builder.to_string();
+NonnullRefPtr<typename parser::ParsedStatement> stmt = (_magic_value.value());
+{
+if (((stmt)->index() == 14 /* Yield */)){
+NonnullRefPtr<typename parser::ParsedExpression> const expr = ((stmt)->get<parser::ParsedStatement::Yield>()).expr;
+return (((expr)->span()));
 }
-ErrorOr<DeprecatedString> parser::ParsedExpression::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Boolean */: {
-TRY(builder.append("ParsedExpression::Boolean"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Boolean>();
-TRY(builder.append("("sv));
+}
+
+}
+}
+
+return (JaktInternal::OptionalNone());
+}
+}
+
+bool parser::ParsedBlock::equals(parser::ParsedBlock const rhs_block) const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: {}", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+if ((((((*this).stmts)).size()) != ((((rhs_block).stmts)).size()))){
+return (false);
 }
-TRY(builder.append(")"sv));
-break;}
-case 1 /* NumericConstant */: {
-TRY(builder.append("ParsedExpression::NumericConstant"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::NumericConstant>();
-TRY(builder.append("("sv));
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: {}", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((*this).stmts)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-TRY(builder.append(")"sv));
-break;}
-case 2 /* QuotedString */: {
-TRY(builder.append("ParsedExpression::QuotedString"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::QuotedString>();
+size_t x = (_magic_value.value());
+{
+if ((!(((((((*this).stmts))[x]))->equals(((((rhs_block).stmts))[x])))))){
+return (false);
+}
+}
+
+}
+}
+
+return (true);
+}
+}
+
+ErrorOr<JaktInternal::Optional<utility::Span>> parser::ParsedBlock::span(parser::Parser const parser) const {
+{
+JaktInternal::Optional<size_t> start = JaktInternal::OptionalNone();
+size_t end = static_cast<size_t>(0ULL);
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((*this).stmts)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename parser::ParsedStatement> stmt = (_magic_value.value());
+{
+utility::Span const stmt_span = ((stmt)->span());
+if ((!(((start).has_value())))){
+(start = ((stmt_span).start));
+}
+(end = ((stmt_span).end));
+}
+
+}
+}
+
+if (((start).has_value())){
+return (((parser).span((start.value()),end)));
+}
+return (JaktInternal::OptionalNone());
+}
+}
+
+JaktInternal::Optional<utility::Span> parser::ParsedBlock::find_yield_keyword_span() const {
+{
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((*this).stmts)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename parser::ParsedStatement> stmt = (_magic_value.value());
+{
+if (((stmt)->index() == 14 /* Yield */)){
+NonnullRefPtr<typename parser::ParsedExpression> const expr = ((stmt)->get<parser::ParsedStatement::Yield>()).expr;
+return (((stmt)->span()));
+}
+}
+
+}
+}
+
+return (JaktInternal::OptionalNone());
+}
+}
+
+ErrorOr<DeprecatedString> parser::ImportName::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Literal */: {
+TRY(builder.append("ImportName::Literal"sv));
+[[maybe_unused]] auto const& that = this->template get<ImportName::Literal>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: \"{}\"", that.val));
+TRY(builder.appendff("name: \"{}\"", that.name));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 3 /* SingleQuotedString */: {
-TRY(builder.append("ParsedExpression::SingleQuotedString"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::SingleQuotedString>();
+case 1 /* Comptime */: {
+TRY(builder.append("ImportName::Comptime"sv));
+[[maybe_unused]] auto const& that = this->template get<ImportName::Comptime>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: \"{}\"", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("prefix: {}", that.prefix));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("expression: {}", that.expression));
 }
 TRY(builder.append(")"sv));
 break;}
-case 4 /* Call */: {
-TRY(builder.append("ParsedExpression::Call"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Call>();
-TRY(builder.append("("sv));
+}
+return builder.to_string();
+}
+DeprecatedString parser::ImportName::literal_name() const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("call: {}", that.call));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+if (((*this).index() == 0 /* Literal */)){
+DeprecatedString const name = ((*this).get<parser::ImportName::Literal>()).name;
+return (name);
 }
-TRY(builder.append(")"sv));
-break;}
-case 5 /* MethodCall */: {
-TRY(builder.append("ParsedExpression::MethodCall"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::MethodCall>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("call: {}", that.call));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+else {
+utility::panic(Jakt::DeprecatedString("Cannot get literal name of non-literal import name"sv));
 }
-TRY(builder.append(")"sv));
-break;}
-case 6 /* IndexedTuple */: {
-TRY(builder.append("ParsedExpression::IndexedTuple"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::IndexedTuple>();
-TRY(builder.append("("sv));
+
+}
+}
+
+bool parser::ImportName::equals(parser::ImportName const other) const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: {}", that.index));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Literal>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = other;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Literal>();DeprecatedString const& other_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue((name == other_name));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Comptime>();NonnullRefPtr<typename parser::ParsedExpression> const& expression = __jakt_match_value.expression;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = other;
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Comptime>();NonnullRefPtr<typename parser::ParsedExpression> const& other_expression = __jakt_match_value.expression;
+return JaktInternal::ExplicitValue(((expression)->equals(other_expression)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-TRY(builder.append(")"sv));
-break;}
-case 7 /* IndexedStruct */: {
-TRY(builder.append("ParsedExpression::IndexedStruct"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::IndexedStruct>();
-TRY(builder.append("("sv));
+}
+
+utility::Span parser::ImportName::span() const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("field_name: \"{}\"", that.field_name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Literal>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Comptime>();NonnullRefPtr<typename parser::ParsedExpression> const& expression = __jakt_match_value.expression;
+{
+return (((expression)->span()));
 }
-TRY(builder.append(")"sv));
-break;}
-case 8 /* ComptimeIndex */: {
-TRY(builder.append("ParsedExpression::ComptimeIndex"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::ComptimeIndex>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
+ErrorOr<DeprecatedString> parser::ParsedMatchPattern::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* EnumVariant */: {
+TRY(builder.append("ParsedMatchPattern::EnumVariant"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedMatchPattern::EnumVariant>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.appendff("defaults: {}", that.defaults));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: {}", that.index));
+TRY(builder.appendff("variant_names: {}", that.variant_names));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.appendff("variant_arguments: {}", that.variant_arguments));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("arguments_span: {}", that.arguments_span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 9 /* Var */: {
-TRY(builder.append("ParsedExpression::Var"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Var>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
+case 1 /* Expression */: {
+TRY(builder.append("ParsedMatchPattern::Expression"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedMatchPattern::Expression>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 10 /* IndexedExpression */: {
-TRY(builder.append("ParsedExpression::IndexedExpression"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::IndexedExpression>();
+case 2 /* CatchAll */: {
+TRY(builder.append("ParsedMatchPattern::CatchAll"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedMatchPattern::CatchAll>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("base: {}", that.base));
+TRY(builder.appendff("defaults: {}", that.defaults));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: {}", that.index));
+TRY(builder.appendff("variant_arguments: {}", that.variant_arguments));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("arguments_span: {}", that.arguments_span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 11 /* UnaryOp */: {
-TRY(builder.append("ParsedExpression::UnaryOp"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::UnaryOp>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("op: {}", that.op));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
+case 3 /* Invalid */: {
+return DeprecatedString("ParsedMatchPattern::Invalid"sv);
 break;}
-case 12 /* BinaryOp */: {
-TRY(builder.append("ParsedExpression::BinaryOp"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::BinaryOp>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("lhs: {}", that.lhs));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("op: {}", that.op));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("rhs: {}", that.rhs));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
 }
-TRY(builder.append(")"sv));
-break;}
-case 13 /* Operator */: {
-TRY(builder.append("ParsedExpression::Operator"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Operator>();
-TRY(builder.append("("sv));
+return builder.to_string();
+}
+bool parser::ParsedMatchPattern::equals(parser::ParsedMatchPattern const rhs_parsed_match_pattern) const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("op: {}", that.op));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+if (((*this).is_equal_pattern(rhs_parsed_match_pattern))){
+if (((*this).defaults_equal(((rhs_parsed_match_pattern).defaults())))){
+if (((*this).index() == 0 /* EnumVariant */)){
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const lhs_variant_arguments = ((*this).get<parser::ParsedMatchPattern::EnumVariant>()).variant_arguments;
+if (((rhs_parsed_match_pattern).index() == 0 /* EnumVariant */)){
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const rhs_variant_arguments = ((rhs_parsed_match_pattern).get<parser::ParsedMatchPattern::EnumVariant>()).variant_arguments;
+if ((((lhs_variant_arguments).size()) == ((rhs_variant_arguments).size()))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_variant_arguments).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-TRY(builder.append(")"sv));
-break;}
-case 14 /* OptionalSome */: {
-TRY(builder.append("ParsedExpression::OptionalSome"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::OptionalSome>();
-TRY(builder.append("("sv));
+size_t i = (_magic_value.value());
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+if ((!(((((lhs_variant_arguments)[i])).equals(((rhs_variant_arguments)[i])))))){
+return (false);
 }
-TRY(builder.append(")"sv));
-break;}
-case 15 /* OptionalNone */: {
-TRY(builder.append("ParsedExpression::OptionalNone"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::OptionalNone>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 16 /* JaktArray */: {
-TRY(builder.append("ParsedExpression::JaktArray"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::JaktArray>();
-TRY(builder.append("("sv));
+}
+
+}
+}
+
+}
+else {
+return (false);
+}
+
+}
+else {
+return (false);
+}
+
+}
+return (true);
+}
+else {
+return (false);
+}
+
+}
+else {
+return (false);
+}
+
+}
+}
+
+bool parser::ParsedMatchPattern::is_equal_pattern(parser::ParsedMatchPattern const rhs_parsed_match_pattern) const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("values: {}", that.values));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("fill_size: {}", that.fill_size));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::EnumVariant>();JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const& lhs_variant_names = __jakt_match_value.variant_names;
+{
+if (((rhs_parsed_match_pattern).index() == 0 /* EnumVariant */)){
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const rhs_variant_names = ((rhs_parsed_match_pattern).get<parser::ParsedMatchPattern::EnumVariant>()).variant_names;
+size_t namespace_count = ((lhs_variant_names).size());
+if ((((rhs_variant_names).size()) < namespace_count)){
+(namespace_count = ((rhs_variant_names).size()));
 }
-TRY(builder.append(")"sv));
-break;}
-case 17 /* JaktDictionary */: {
-TRY(builder.append("ParsedExpression::JaktDictionary"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::JaktDictionary>();
-TRY(builder.append("("sv));
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("values: {}", that.values));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(namespace_count)});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-TRY(builder.append(")"sv));
-break;}
-case 18 /* Set */: {
-TRY(builder.append("ParsedExpression::Set"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Set>();
-TRY(builder.append("("sv));
+size_t i = (_magic_value.value());
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("values: {}", that.values));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+DeprecatedString const lhs_name = ((((lhs_variant_names)[(JaktInternal::checked_sub<size_t>((JaktInternal::checked_sub<size_t>(((lhs_variant_names).size()),i)),static_cast<size_t>(1ULL)))])).template get<0>());
+DeprecatedString const rhs_name = ((((rhs_variant_names)[(JaktInternal::checked_sub<size_t>((JaktInternal::checked_sub<size_t>(((rhs_variant_names).size()),i)),static_cast<size_t>(1ULL)))])).template get<0>());
+if ((lhs_name == rhs_name)){
 }
-TRY(builder.append(")"sv));
-break;}
-case 19 /* JaktTuple */: {
-TRY(builder.append("ParsedExpression::JaktTuple"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::JaktTuple>();
-TRY(builder.append("("sv));
+else {
+return (false);
+}
+
+}
+
+}
+}
+
+return (true);
+}
+else {
+return (false);
+}
+
+}
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchPattern::Expression>();
+NonnullRefPtr<typename parser::ParsedExpression> const& lhs_parsed_expression = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = rhs_parsed_match_pattern;
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchPattern::Expression>();
+NonnullRefPtr<typename parser::ParsedExpression> const& rhs_parsed_expression = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((lhs_parsed_expression)->equals(rhs_parsed_expression)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(((rhs_parsed_match_pattern).index() == 2 /* CatchAll */));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(((rhs_parsed_match_pattern).index() == 3 /* Invalid */));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
+bool parser::ParsedMatchPattern::defaults_equal(JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const defaults) const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("values: {}", that.values));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+if ((((defaults).size()) != ((((*this).defaults())).size()))){
+return (false);
 }
-TRY(builder.append(")"sv));
-break;}
-case 20 /* Range */: {
-TRY(builder.append("ParsedExpression::Range"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Range>();
-TRY(builder.append("("sv));
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("from: {}", that.from));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("to: {}", that.to));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((*this).defaults())).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-TRY(builder.append(")"sv));
-break;}
-case 21 /* ForcedUnwrap */: {
-TRY(builder.append("ParsedExpression::ForcedUnwrap"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::ForcedUnwrap>();
-TRY(builder.append("("sv));
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> name__default___ = (_magic_value.value());
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt__name__default___ = name__default___;
+DeprecatedString const name = ((jakt__name__default___).template get<0>());
+parser::ParsedPatternDefault const default_ = ((jakt__name__default___).template get<1>());
+
+JaktInternal::Optional<parser::ParsedPatternDefault> const matching = ((defaults).get(name));
+if ((!(((matching).has_value())))){
+return (false);
 }
-TRY(builder.append(")"sv));
+if ((!((((((matching.value())).value))->equals(((default_).value)))))){
+return (false);
+}
+if (((((((matching.value())).variable)).is_mutable) != ((((default_).variable)).is_mutable))){
+return (false);
+}
+}
+
+}
+}
+
+return (true);
+}
+}
+
+ErrorOr<DeprecatedString> parser::Visibility::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Public */: {
+return DeprecatedString("Visibility::Public"sv);
 break;}
-case 22 /* Match */: {
-TRY(builder.append("ParsedExpression::Match"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Match>();
+case 1 /* Private */: {
+return DeprecatedString("Visibility::Private"sv);
+break;}
+case 2 /* Restricted */: {
+TRY(builder.append("Visibility::Restricted"sv));
+[[maybe_unused]] auto const& that = this->template get<Visibility::Restricted>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("cases: {}", that.cases));
+TRY(builder.appendff("whitelist: {}", that.whitelist));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("marker_span: {}", that.marker_span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 23 /* EnumVariantArg */: {
-TRY(builder.append("ParsedExpression::EnumVariantArg"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::EnumVariantArg>();
+}
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> parser::ArgumentStoreLevel::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* InObject */: {
+TRY(builder.append("ArgumentStoreLevel::InObject"sv));
+[[maybe_unused]] auto const& that = this->template get<ArgumentStoreLevel::InObject>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("arg: {}", that.arg));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("enum_variant: {}", that.enum_variant));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("argument_index: {}", that.argument_index));
 }
 TRY(builder.append(")"sv));
 break;}
-case 24 /* NamespacedVar */: {
-TRY(builder.append("ParsedExpression::NamespacedVar"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::NamespacedVar>();
+case 1 /* InStaticStorage */: {
+return DeprecatedString("ArgumentStoreLevel::InStaticStorage"sv);
+break;}
+}
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> parser::ParsedMatchBody::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Expression */: {
+TRY(builder.append("ParsedMatchBody::Expression"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedMatchBody::Expression>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 1 /* Block */: {
+TRY(builder.append("ParsedMatchBody::Block"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedMatchBody::Block>();
+TRY(builder.appendff("({})", that.value));
+break;}
+}
+return builder.to_string();
+}
+bool parser::ParsedMatchBody::equals(parser::ParsedMatchBody const rhs_match_body) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchBody::Expression>();
+NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_111; {
+__jakt_var_111 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
+auto __jakt_enum_value = (((rhs_match_body).index() == 0 /* Expression */));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_112; {
+NonnullRefPtr<typename parser::ParsedExpression> const rhs_expr = ((rhs_match_body).get<parser::ParsedMatchBody::Expression>()).value;
+__jakt_var_112 = ((lhs_expr)->equals(rhs_expr)); goto __jakt_label_108;
+
+}
+__jakt_label_108:; __jakt_var_112.release_value(); }));
+}
+else {
+{
+return (false);
+}
+}
+}()))
+; goto __jakt_label_107;
+
+}
+__jakt_label_107:; __jakt_var_111.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchBody::Block>();
+parser::ParsedBlock const& lhs_block = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_113; {
+__jakt_var_113 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
+auto __jakt_enum_value = (((rhs_match_body).index() == 1 /* Block */));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_114; {
+parser::ParsedBlock const rhs_block = ((rhs_match_body).get<parser::ParsedMatchBody::Block>()).value;
+__jakt_var_114 = ((lhs_block).equals(rhs_block)); goto __jakt_label_110;
+
+}
+__jakt_label_110:; __jakt_var_114.release_value(); }));
+}
+else {
+{
+return (false);
+}
+}
+}()))
+; goto __jakt_label_109;
+
+}
+__jakt_label_109:; __jakt_var_113.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
+ErrorOr<DeprecatedString> parser::ParsedCapture::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* ByValue */: {
+return DeprecatedString("ParsedCapture::ByValue"sv);
+break;}
+case 1 /* ByReference */: {
+return DeprecatedString("ParsedCapture::ByReference"sv);
+break;}
+case 2 /* ByMutableReference */: {
+return DeprecatedString("ParsedCapture::ByMutableReference"sv);
+break;}
+case 3 /* ByComptimeDependency */: {
+return DeprecatedString("ParsedCapture::ByComptimeDependency"sv);
+break;}
+case 4 /* AllByReference */: {
+return DeprecatedString("ParsedCapture::AllByReference"sv);
+break;}
+}
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> parser::ParsedType::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Name */: {
+TRY(builder.append("ParsedType::Name"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::Name>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
@@ -11226,120 +11265,215 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("name: \"{}\"", that.name));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("namespace_: {}", that.namespace_));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 25 /* Function */: {
-TRY(builder.append("ParsedExpression::Function"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Function>();
+case 1 /* NamespacedName */: {
+TRY(builder.append("ParsedType::NamespacedName"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::NamespacedName>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("captures: {}", that.captures));
+TRY(builder.appendff("name: \"{}\"", that.name));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("params: {}", that.params));
+TRY(builder.appendff("namespaces: {}", that.namespaces));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("can_throw: {}", that.can_throw));
+TRY(builder.appendff("params: {}", that.params));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_fat_arrow: {}", that.is_fat_arrow));
-TRY(builder.append(", "sv));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 2 /* GenericType */: {
+TRY(builder.append("ParsedType::GenericType"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::GenericType>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("return_type: {}", that.return_type));
+TRY(builder.appendff("name: \"{}\"", that.name));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("generic_parameters: {}", that.generic_parameters));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 26 /* Try */: {
-TRY(builder.append("ParsedExpression::Try"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Try>();
+case 3 /* JaktArray */: {
+TRY(builder.append("ParsedType::JaktArray"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::JaktArray>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.appendff("inner: {}", that.inner));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("catch_block: {}", that.catch_block));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 4 /* Dictionary */: {
+TRY(builder.append("ParsedType::Dictionary"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::Dictionary>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("key: {}", that.key));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("catch_name: {}", that.catch_name));
+TRY(builder.appendff("value: {}", that.value));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 27 /* TryBlock */: {
-TRY(builder.append("ParsedExpression::TryBlock"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::TryBlock>();
+case 5 /* JaktTuple */: {
+TRY(builder.append("ParsedType::JaktTuple"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::JaktTuple>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("stmt: {}", that.stmt));
+TRY(builder.appendff("types: {}", that.types));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("error_name: \"{}\"", that.error_name));
-TRY(builder.append(", "sv));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 6 /* Set */: {
+TRY(builder.append("ParsedType::Set"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::Set>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("error_span: {}", that.error_span));
+TRY(builder.appendff("inner: {}", that.inner));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("catch_block: {}", that.catch_block));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 7 /* Optional */: {
+TRY(builder.append("ParsedType::Optional"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::Optional>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("inner: {}", that.inner));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 28 /* Reflect */: {
-TRY(builder.append("ParsedExpression::Reflect"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Reflect>();
+case 8 /* Reference */: {
+TRY(builder.append("ParsedType::Reference"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::Reference>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type: {}", that.type));
+TRY(builder.appendff("inner: {}", that.inner));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 29 /* Garbage */: {
-TRY(builder.append("ParsedExpression::Garbage"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Garbage>();
-TRY(builder.appendff("({})", that.value));
+case 9 /* MutableReference */: {
+TRY(builder.append("ParsedType::MutableReference"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::MutableReference>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
 break;}
+case 10 /* RawPtr */: {
+TRY(builder.append("ParsedType::RawPtr"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::RawPtr>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-return builder.to_string();
+TRY(builder.append(")"sv));
+break;}
+case 11 /* WeakPtr */: {
+TRY(builder.append("ParsedType::WeakPtr"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::WeakPtr>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-bool parser::ParsedExpression::equals(NonnullRefPtr<typename parser::ParsedExpression> const rhs_expression) const {
+TRY(builder.append(")"sv));
+break;}
+case 12 /* Function */: {
+TRY(builder.append("ParsedType::Function"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedType::Function>();
+TRY(builder.append("("sv));
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("params: {}", that.params));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("can_throw: {}", that.can_throw));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("return_type: {}", that.return_type));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 13 /* Empty */: {
+return DeprecatedString("ParsedType::Empty"sv);
+break;}
+}
+return builder.to_string();
+}
+bool parser::ParsedType::equals(NonnullRefPtr<typename parser::ParsedType> const rhs_parsed_type) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Boolean>();bool const& lhs_val = __jakt_match_value.val;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& lhs_name = __jakt_match_value.name;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Boolean>();bool const& rhs_val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue((lhs_val == rhs_val));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& rhs_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue((lhs_name == rhs_name));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11349,13 +11483,62 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NumericConstant>();parser::NumericConstant const& lhs_val = __jakt_match_value.val;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& lhs_name = __jakt_match_value.name;
+JaktInternal::DynamicArray<DeprecatedString> const& lhs_namespaces = __jakt_match_value.namespaces;
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& lhs_params = __jakt_match_value.params;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NumericConstant>();parser::NumericConstant const& rhs_val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue((((lhs_val).to_usize()) == ((rhs_val).to_usize())));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& rhs_name = __jakt_match_value.name;
+JaktInternal::DynamicArray<DeprecatedString> const& rhs_namespaces = __jakt_match_value.namespaces;
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& rhs_params = __jakt_match_value.params;
+{
+if ((lhs_name != rhs_name)){
+return (false);
+}
+if ((((lhs_namespaces).size()) != ((rhs_namespaces).size()))){
+return (false);
+}
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_namespaces).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t namespace_index = (_magic_value.value());
+{
+if ((((lhs_namespaces)[namespace_index]) != ((rhs_namespaces)[namespace_index]))){
+return (false);
+}
+}
+
+}
+}
+
+if ((((lhs_params).size()) != ((rhs_params).size()))){
+return (false);
+}
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_params).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t param_index = (_magic_value.value());
+{
+if ((!(((((lhs_params)[param_index]))->equals(((rhs_params)[param_index])))))){
+return (false);
+}
+}
+
+}
+}
+
+return (true);
+}
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11365,13 +11548,40 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::QuotedString>();DeprecatedString const& lhs_val = __jakt_match_value.val;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::GenericType>();DeprecatedString const& lhs_name = __jakt_match_value.name;
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& lhs_generic_parameters = __jakt_match_value.generic_parameters;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::QuotedString>();DeprecatedString const& rhs_val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue((lhs_val == rhs_val));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::GenericType>();DeprecatedString const& rhs_name = __jakt_match_value.name;
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& rhs_generic_parameters = __jakt_match_value.generic_parameters;
+{
+if ((lhs_name != rhs_name)){
+return (false);
+}
+if ((((lhs_generic_parameters).size()) != ((rhs_generic_parameters).size()))){
+return (false);
+}
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_generic_parameters).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t param_index = (_magic_value.value());
+{
+if ((!(((((lhs_generic_parameters)[param_index]))->equals(((rhs_generic_parameters)[param_index])))))){
+return (false);
+}
+}
+
+}
+}
+
+return (true);
+}
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11381,15 +11591,13 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::SingleQuotedString>();DeprecatedString const& lhs_val = __jakt_match_value.val;
-JaktInternal::Optional<DeprecatedString> const& lhs_prefix = __jakt_match_value.prefix;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktArray>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::SingleQuotedString>();DeprecatedString const& rhs_val = __jakt_match_value.val;
-JaktInternal::Optional<DeprecatedString> const& rhs_prefix = __jakt_match_value.prefix;
-return JaktInternal::ExplicitValue(((lhs_val == rhs_val) && (lhs_prefix == rhs_prefix)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktArray>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11399,13 +11607,15 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Call>();parser::ParsedCall const& lhs_call = __jakt_match_value.call;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Dictionary>();NonnullRefPtr<typename parser::ParsedType> const& lhs_key = __jakt_match_value.key;
+NonnullRefPtr<typename parser::ParsedType> const& lhs_value = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Call>();parser::ParsedCall const& rhs_call = __jakt_match_value.call;
-return JaktInternal::ExplicitValue(((lhs_call).equals(rhs_call)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Dictionary>();NonnullRefPtr<typename parser::ParsedType> const& rhs_key = __jakt_match_value.key;
+NonnullRefPtr<typename parser::ParsedType> const& rhs_value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((((lhs_key)->equals(rhs_key)) && ((lhs_value)->equals(rhs_value))));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11415,17 +11625,35 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::MethodCall>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-parser::ParsedCall const& lhs_call = __jakt_match_value.call;
-bool const& lhs_optional = __jakt_match_value.is_optional;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& lhs_types = __jakt_match_value.types;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::MethodCall>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-parser::ParsedCall const& rhs_call = __jakt_match_value.call;
-bool const& rhs_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue((((lhs_optional == rhs_optional) && ((lhs_expr)->equals(rhs_expr))) && ((lhs_call).equals(rhs_call))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& rhs_types = __jakt_match_value.types;
+{
+if ((((lhs_types).size()) != ((rhs_types).size()))){
+return (false);
+}
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_types).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t type_index = (_magic_value.value());
+{
+if ((!(((((lhs_types)[type_index]))->equals(((rhs_types)[type_index])))))){
+return (false);
+}
+}
+
+}
+}
+
+return (true);
+}
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11435,17 +11663,13 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedTuple>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-size_t const& lhs_index = __jakt_match_value.index;
-bool const& lhs_optional = __jakt_match_value.is_optional;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Set>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedTuple>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-size_t const& rhs_index = __jakt_match_value.index;
-bool const& rhs_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue((((lhs_optional == rhs_optional) && ((lhs_expr)->equals(rhs_expr))) && (lhs_index == rhs_index)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Set>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11455,17 +11679,13 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedStruct>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-DeprecatedString const& lhs_field = __jakt_match_value.field_name;
-bool const& lhs_optional = __jakt_match_value.is_optional;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Optional>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedStruct>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-DeprecatedString const& rhs_field = __jakt_match_value.field_name;
-bool const& rhs_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue((((lhs_optional == rhs_optional) && ((lhs_expr)->equals(rhs_expr))) && (lhs_field == rhs_field)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Optional>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11475,17 +11695,13 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ComptimeIndex>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-NonnullRefPtr<typename parser::ParsedExpression> const& lhs_index = __jakt_match_value.index;
-bool const& lhs_optional = __jakt_match_value.is_optional;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Reference>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ComptimeIndex>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-NonnullRefPtr<typename parser::ParsedExpression> const& rhs_index = __jakt_match_value.index;
-bool const& rhs_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue((((lhs_optional == rhs_optional) && ((lhs_expr)->equals(rhs_expr))) && ((lhs_index)->equals(rhs_index))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Reference>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11495,13 +11711,13 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();DeprecatedString const& lhs_name = __jakt_match_value.name;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::MutableReference>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();DeprecatedString const& rhs_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue((lhs_name == rhs_name));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::MutableReference>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11511,15 +11727,13 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedExpression>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_base = __jakt_match_value.base;
-NonnullRefPtr<typename parser::ParsedExpression> const& lhs_index = __jakt_match_value.index;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::RawPtr>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedExpression>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_base = __jakt_match_value.base;
-NonnullRefPtr<typename parser::ParsedExpression> const& rhs_index = __jakt_match_value.index;
-return JaktInternal::ExplicitValue((((lhs_base)->equals(rhs_base)) && ((lhs_index)->equals(rhs_index))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::RawPtr>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11529,15 +11743,13 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-parser::UnaryOperator const& lhs_op = __jakt_match_value.op;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::WeakPtr>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-parser::UnaryOperator const& rhs_op = __jakt_match_value.op;
-return JaktInternal::ExplicitValue((((lhs_expr)->equals(rhs_expr)) && ((lhs_op).equals(rhs_op))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::WeakPtr>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11547,98 +11759,36 @@ return JaktInternal::ExplicitValue(false);
 )));
 };/*case end*/
 case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_lhs = __jakt_match_value.lhs;
-parser::BinaryOperator const& lhs_op = __jakt_match_value.op;
-NonnullRefPtr<typename parser::ParsedExpression> const& lhs_rhs = __jakt_match_value.rhs;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Function>();JaktInternal::DynamicArray<parser::ParsedParameter> const& lhs_params = __jakt_match_value.params;
+bool const& lhs_can_throw = __jakt_match_value.can_throw;
+NonnullRefPtr<typename parser::ParsedType> const& lhs_return_type = __jakt_match_value.return_type;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+auto&& __jakt_match_variant = *rhs_parsed_type;
 switch(__jakt_match_variant.index()) {
 case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_lhs = __jakt_match_value.lhs;
-parser::BinaryOperator const& rhs_op = __jakt_match_value.op;
-NonnullRefPtr<typename parser::ParsedExpression> const& rhs_rhs = __jakt_match_value.rhs;
-return JaktInternal::ExplicitValue(((((lhs_lhs)->equals(rhs_lhs)) && ((lhs_op).equals(rhs_op))) && ((lhs_rhs)->equals(rhs_rhs))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& lhs_op = __jakt_match_value.op;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& rhs_op = __jakt_match_value.op;
-return JaktInternal::ExplicitValue(((lhs_op).equals(rhs_op)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::OptionalSome>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::OptionalSome>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(((rhs_expression)->index() == 15 /* OptionalNone */));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_values = __jakt_match_value.values;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_fill_size = __jakt_match_value.fill_size;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_values = __jakt_match_value.values;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_fill_size = __jakt_match_value.fill_size;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_111; {
-if ((!(((lhs_fill_size).has_value())))){
-if (((rhs_fill_size).has_value())){
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Function>();JaktInternal::DynamicArray<parser::ParsedParameter> const& rhs_params = __jakt_match_value.params;
+bool const& rhs_can_throw = __jakt_match_value.can_throw;
+NonnullRefPtr<typename parser::ParsedType> const& rhs_return_type = __jakt_match_value.return_type;
+{
+if ((lhs_can_throw != rhs_can_throw)){
 return (false);
 }
-}
-else {
-if ((!(((rhs_fill_size).has_value())))){
+if ((!(((lhs_return_type)->equals(rhs_return_type))))){
 return (false);
 }
-if ((!((((lhs_fill_size.value()))->equals((rhs_fill_size.value())))))){
+if ((((lhs_params).size()) != ((rhs_params).size()))){
 return (false);
 }
-}
-
-__jakt_var_111 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
-auto __jakt_enum_value = ((((lhs_values).size()) == ((rhs_values).size())));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_112; {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_values).size()))});
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_params).size()))});
 for (;;){
 JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+size_t param_index = (_magic_value.value());
 {
-if ((!(((((lhs_values)[i]))->equals(((rhs_values)[i])))))){
+if ((!(((((lhs_params)[param_index])).equals(((rhs_params)[param_index])))))){
 return (false);
 }
 }
@@ -11646,21 +11796,8 @@ return (false);
 }
 }
 
-__jakt_var_112 = true; goto __jakt_label_108;
-
-}
-__jakt_label_108:; __jakt_var_112.release_value(); }));
-}
-else {
-{
-return (false);
-}
-}
-}()))
-; goto __jakt_label_107;
-
+return (true);
 }
-__jakt_label_107:; __jakt_var_111.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -11669,1118 +11806,375 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const& lhs_values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const& rhs_values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_113; {
-__jakt_var_113 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
-auto __jakt_enum_value = ((((lhs_values).size()) == ((rhs_values).size())));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_114; {
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_values).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if ((!((((((((lhs_values)[i])).template get<0>()))->equals(((((rhs_values)[i])).template get<0>()))) && ((((((lhs_values)[i])).template get<1>()))->equals(((((rhs_values)[i])).template get<1>()))))))){
-return (false);
+case 13: {
+return JaktInternal::ExplicitValue(((rhs_parsed_type)->index() == 13 /* Empty */));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
 }
 
+utility::Span parser::ParsedType::span() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 13: {
+return JaktInternal::ExplicitValue(utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::GenericType>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktArray>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Dictionary>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktTuple>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Set>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Optional>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Reference>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::MutableReference>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::RawPtr>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::WeakPtr>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Function>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
 }
 
-__jakt_var_114 = true; goto __jakt_label_110;
-
+ErrorOr<DeprecatedString> parser::TypeCast::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Fallible */: {
+TRY(builder.append("TypeCast::Fallible"sv));
+[[maybe_unused]] auto const& that = this->template get<TypeCast::Fallible>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 1 /* Infallible */: {
+TRY(builder.append("TypeCast::Infallible"sv));
+[[maybe_unused]] auto const& that = this->template get<TypeCast::Infallible>();
+TRY(builder.appendff("({})", that.value));
+break;}
 }
-__jakt_label_110:; __jakt_var_114.release_value(); }));
+return builder.to_string();
 }
-else {
+NonnullRefPtr<typename parser::ParsedType> parser::TypeCast::parsed_type() const {
 {
-return (false);
-}
-}
-}()))
-; goto __jakt_label_109;
-
-}
-__jakt_label_109:; __jakt_var_113.release_value(); }));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, NonnullRefPtr<typename parser::ParsedType>>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::TypeCast::Fallible>();
+NonnullRefPtr<typename parser::ParsedType> const& parsed_type = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(parsed_type);
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::TypeCast::Infallible>();
+NonnullRefPtr<typename parser::ParsedType> const& parsed_type = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(parsed_type);
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-};/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Set>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Set>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_115; {
-__jakt_var_115 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
-auto __jakt_enum_value = ((((lhs_values).size()) == ((rhs_values).size())));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_116; {
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_values).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if ((!(((((lhs_values)[i]))->equals(((rhs_values)[i])))))){
-return (false);
 }
 }
 
+ErrorOr<DeprecatedString> parser::DefinitionLinkage::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Internal */: {
+return DeprecatedString("DefinitionLinkage::Internal"sv);
+break;}
+case 1 /* External */: {
+return DeprecatedString("DefinitionLinkage::External"sv);
+break;}
 }
+return builder.to_string();
 }
-
-__jakt_var_116 = true; goto __jakt_label_112;
-
+ErrorOr<DeprecatedString> parser::ImportList::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* List */: {
+TRY(builder.append("ImportList::List"sv));
+[[maybe_unused]] auto const& that = this->template get<ImportList::List>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 1 /* All */: {
+return DeprecatedString("ImportList::All"sv);
+break;}
 }
-__jakt_label_112:; __jakt_var_116.release_value(); }));
+return builder.to_string();
 }
-else {
+ErrorOr<void> parser::ImportList::add(parser::ImportName const name) {
 {
-return (false);
-}
-}
-}()))
-; goto __jakt_label_111;
-
-}
-__jakt_label_111:; __jakt_var_115.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_117; {
-__jakt_var_117 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
-auto __jakt_enum_value = ((((lhs_values).size()) == ((rhs_values).size())));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_118; {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ImportList::List>();
+JaktInternal::DynamicArray<parser::ImportName> const& names = __jakt_match_value.value;
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_values).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::DynamicArray<parser::ImportName> mutable_names = names;
+TRY((((mutable_names).push(name))));
 }
-size_t i = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
 {
-if ((!(((((lhs_values)[i]))->equals(((rhs_values)[i])))))){
-return (false);
-}
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
 }
+return {};
 }
 
-__jakt_var_118 = true; goto __jakt_label_114;
-
-}
-__jakt_label_114:; __jakt_var_118.release_value(); }));
-}
-else {
+bool parser::ImportList::is_empty() const {
 {
-return (false);
-}
-}
-}()))
-; goto __jakt_label_113;
-
-}
-__jakt_label_113:; __jakt_var_117.release_value(); }));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ImportList::List>();
+JaktInternal::DynamicArray<parser::ImportName> const& names = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((names).is_empty()));
 };/*case end*/
-default: {
+case 1: {
 return JaktInternal::ExplicitValue(false);
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_from = __jakt_match_value.from;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_to = __jakt_match_value.to;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_from = __jakt_match_value.from;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_to = __jakt_match_value.to;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_119; {
-bool equal = false;
-if (((((lhs_from).has_value()) == ((rhs_from).has_value())) && (((lhs_to).has_value()) == ((rhs_to).has_value())))){
-if ((((lhs_from).has_value()) && ((lhs_to).has_value()))){
-(equal = ((((lhs_from.value()))->equals((rhs_from.value()))) && (((lhs_to.value()))->equals((rhs_to.value())))));
 }
-else {
-(equal = true);
-}
-
 }
-__jakt_var_119 = equal; goto __jakt_label_115;
 
-}
-__jakt_label_115:; __jakt_var_119.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ForcedUnwrap>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ForcedUnwrap>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Match>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-JaktInternal::DynamicArray<parser::ParsedMatchCase> const& lhs_cases = __jakt_match_value.cases;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Match>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-JaktInternal::DynamicArray<parser::ParsedMatchCase> const& rhs_cases = __jakt_match_value.cases;
-{
-if ((((lhs_expr)->equals(rhs_expr)) && (((lhs_cases).size()) == ((rhs_cases).size())))){
+ErrorOr<DeprecatedString> parser::ParsedExpression::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Boolean */: {
+TRY(builder.append("ParsedExpression::Boolean"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Boolean>();
+TRY(builder.append("("sv));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_cases).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("val: {}", that.val));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-size_t i = (_magic_value.value());
-{
-bool current_case_has_match = false;
+TRY(builder.append(")"sv));
+break;}
+case 1 /* NumericConstant */: {
+TRY(builder.append("ParsedExpression::NumericConstant"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::NumericConstant>();
+TRY(builder.append("("sv));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((rhs_cases).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("val: {}", that.val));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-size_t k = (_magic_value.value());
+TRY(builder.append(")"sv));
+break;}
+case 2 /* QuotedString */: {
+TRY(builder.append("ParsedExpression::QuotedString"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::QuotedString>();
+TRY(builder.append("("sv));
 {
-if (((((lhs_cases)[i])).equals(((rhs_cases)[k])))){
-(current_case_has_match = true);
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("val: \"{}\"", that.val));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
+TRY(builder.append(")"sv));
+break;}
+case 3 /* SingleQuotedString */: {
+TRY(builder.append("ParsedExpression::SingleQuotedString"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::SingleQuotedString>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("val: \"{}\"", that.val));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("prefix: {}", that.prefix));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-
+TRY(builder.append(")"sv));
+break;}
+case 4 /* Call */: {
+TRY(builder.append("ParsedExpression::Call"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Call>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("call: {}", that.call));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
+TRY(builder.append(")"sv));
+break;}
+case 5 /* MethodCall */: {
+TRY(builder.append("ParsedExpression::MethodCall"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::MethodCall>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("call: {}", that.call));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-
-if (current_case_has_match){
-}
-else {
-return (false);
-}
-
-}
-
-}
-}
-
-return (true);
-}
-else {
-return (false);
-}
-
-}
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::EnumVariantArg>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::EnumVariantArg>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NamespacedVar>();DeprecatedString const& lhs_name = __jakt_match_value.name;
-JaktInternal::DynamicArray<DeprecatedString> const& lhs_namespace = __jakt_match_value.namespace_;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NamespacedVar>();DeprecatedString const& rhs_name = __jakt_match_value.name;
-JaktInternal::DynamicArray<DeprecatedString> const& rhs_namespace = __jakt_match_value.namespace_;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_120; {
-if ((((lhs_namespace).size()) != ((rhs_namespace).size()))){
-return (false);
-}
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_namespace).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if ((((lhs_namespace)[i]) != ((rhs_namespace)[i]))){
-return (false);
-}
-}
-
-}
-}
-
-__jakt_var_120 = (lhs_name == rhs_name); goto __jakt_label_116;
-
-}
-__jakt_label_116:; __jakt_var_120.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Try>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-JaktInternal::Optional<parser::ParsedBlock> const& lhs_catch_block = __jakt_match_value.catch_block;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Try>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-JaktInternal::Optional<parser::ParsedBlock> const& rhs_catch_block = __jakt_match_value.catch_block;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_121; {
-bool equals = ((lhs_expr)->equals(rhs_expr));
-if (equals){
-if (((lhs_catch_block).has_value())){
-if (((rhs_catch_block).has_value())){
-(equals = (((lhs_catch_block.value())).equals((rhs_catch_block.value()))));
-}
-else {
-(equals = false);
-}
-
-}
-else {
-(equals = (!(((rhs_catch_block).has_value()))));
-}
-
-}
-__jakt_var_121 = equals; goto __jakt_label_117;
-
-}
-__jakt_label_117:; __jakt_var_121.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::TryBlock>();NonnullRefPtr<typename parser::ParsedStatement> const& lhs_stmt = __jakt_match_value.stmt;
-DeprecatedString const& lhs_error_name = __jakt_match_value.error_name;
-parser::ParsedBlock const& lhs_catch_block = __jakt_match_value.catch_block;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::TryBlock>();NonnullRefPtr<typename parser::ParsedStatement> const& rhs_stmt = __jakt_match_value.stmt;
-DeprecatedString const& rhs_error_name = __jakt_match_value.error_name;
-parser::ParsedBlock const& rhs_catch_block = __jakt_match_value.catch_block;
-return JaktInternal::ExplicitValue(((((lhs_stmt)->equals(rhs_stmt)) && (lhs_error_name == rhs_error_name)) && ((lhs_catch_block).equals(rhs_catch_block))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Function>();JaktInternal::DynamicArray<parser::ParsedCapture> const& lhs_captures = __jakt_match_value.captures;
-JaktInternal::DynamicArray<parser::ParsedParameter> const& lhs_params = __jakt_match_value.params;
-bool const& lhs_can_throw = __jakt_match_value.can_throw;
-NonnullRefPtr<typename parser::ParsedType> const& lhs_return_type = __jakt_match_value.return_type;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Function>();JaktInternal::DynamicArray<parser::ParsedCapture> const& rhs_captures = __jakt_match_value.captures;
-JaktInternal::DynamicArray<parser::ParsedParameter> const& rhs_params = __jakt_match_value.params;
-bool const& rhs_can_throw = __jakt_match_value.can_throw;
-NonnullRefPtr<typename parser::ParsedType> const& rhs_return_type = __jakt_match_value.return_type;
-{
-if ((((lhs_return_type)->equals(rhs_return_type)) && ((lhs_can_throw == rhs_can_throw) && ((((lhs_captures).size()) == ((rhs_captures).size())) && (((lhs_params).size()) == ((rhs_params).size())))))){
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_captures).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if ((!((((((lhs_captures)[i])).name()) == ((((rhs_captures)[i])).name()))))){
-return (false);
-}
-}
-
-}
-}
-
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_params).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if ((!(((((lhs_params)[i])).equals(((rhs_params)[i])))))){
-return (false);
-}
-}
-
-}
-}
-
-return (true);
-}
-else {
-return (false);
-}
-
-}
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Reflect>();NonnullRefPtr<typename parser::ParsedType> const& type = __jakt_match_value.type;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_expression;
-switch(__jakt_match_variant.index()) {
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Reflect>();NonnullRefPtr<typename parser::ParsedType> const& rhs_type = __jakt_match_value.type;
-return JaktInternal::ExplicitValue(((type)->equals(rhs_type)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue(((rhs_expression)->index() == 29 /* Garbage */));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-utility::Span parser::ParsedExpression::span() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Boolean>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NumericConstant>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::QuotedString>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Call>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::MethodCall>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedTuple>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedStruct>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ComptimeIndex>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedExpression>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::OptionalSome>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedExpression::OptionalNone>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktArray>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktDictionary>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Set>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktTuple>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Range>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ForcedUnwrap>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Match>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::EnumVariantArg>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NamespacedVar>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Function>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Try>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::TryBlock>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Reflect>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedExpression::Garbage>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-i64 parser::ParsedExpression::precedence() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& op = __jakt_match_value.op;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue(static_cast<i64>(100LL));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(static_cast<i64>(100LL));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(static_cast<i64>(100LL));
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(static_cast<i64>(90LL));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(static_cast<i64>(90LL));
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(static_cast<i64>(85LL));
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(static_cast<i64>(85LL));
-};/*case end*/
-case 16: {
-return JaktInternal::ExplicitValue(static_cast<i64>(85LL));
-};/*case end*/
-case 17: {
-return JaktInternal::ExplicitValue(static_cast<i64>(85LL));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(static_cast<i64>(73LL));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(static_cast<i64>(72LL));
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(static_cast<i64>(71LL));
-};/*case end*/
-case 18: {
-return JaktInternal::ExplicitValue(static_cast<i64>(70LL));
-};/*case end*/
-case 19: {
-return JaktInternal::ExplicitValue(static_cast<i64>(69LL));
-};/*case end*/
-case 20: {
-return JaktInternal::ExplicitValue(static_cast<i64>(69LL));
-};/*case end*/
-case 21: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 22: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 23: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 24: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 26: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 27: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-case 32: {
-return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<DeprecatedString> parser::ImportList::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* List */: {
-TRY(builder.append("ImportList::List"sv));
-[[maybe_unused]] auto const& that = this->template get<ImportList::List>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* All */: {
-return DeprecatedString("ImportList::All"sv);
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<void> parser::ImportList::add(parser::ImportName const name) {
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ImportList::List>();
-JaktInternal::DynamicArray<parser::ImportName> const& names = __jakt_match_value.value;
-{
-JaktInternal::DynamicArray<parser::ImportName> mutable_names = names;
-TRY((((mutable_names).push(name))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-}
-return {};
-}
-
-bool parser::ImportList::is_empty() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ImportList::List>();
-JaktInternal::DynamicArray<parser::ImportName> const& names = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((names).is_empty()));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<DeprecatedString> parser::ParsedCapture::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* ByValue */: {
-return DeprecatedString("ParsedCapture::ByValue"sv);
-break;}
-case 1 /* ByReference */: {
-return DeprecatedString("ParsedCapture::ByReference"sv);
-break;}
-case 2 /* ByMutableReference */: {
-return DeprecatedString("ParsedCapture::ByMutableReference"sv);
-break;}
-case 3 /* ByComptimeDependency */: {
-return DeprecatedString("ParsedCapture::ByComptimeDependency"sv);
-break;}
-case 4 /* AllByReference */: {
-return DeprecatedString("ParsedCapture::AllByReference"sv);
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> parser::BinaryOperator::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Add */: {
-return DeprecatedString("BinaryOperator::Add"sv);
-break;}
-case 1 /* Subtract */: {
-return DeprecatedString("BinaryOperator::Subtract"sv);
-break;}
-case 2 /* Multiply */: {
-return DeprecatedString("BinaryOperator::Multiply"sv);
-break;}
-case 3 /* Divide */: {
-return DeprecatedString("BinaryOperator::Divide"sv);
-break;}
-case 4 /* Modulo */: {
-return DeprecatedString("BinaryOperator::Modulo"sv);
-break;}
-case 5 /* LessThan */: {
-return DeprecatedString("BinaryOperator::LessThan"sv);
-break;}
-case 6 /* LessThanOrEqual */: {
-return DeprecatedString("BinaryOperator::LessThanOrEqual"sv);
-break;}
-case 7 /* GreaterThan */: {
-return DeprecatedString("BinaryOperator::GreaterThan"sv);
-break;}
-case 8 /* GreaterThanOrEqual */: {
-return DeprecatedString("BinaryOperator::GreaterThanOrEqual"sv);
-break;}
-case 9 /* Equal */: {
-return DeprecatedString("BinaryOperator::Equal"sv);
-break;}
-case 10 /* NotEqual */: {
-return DeprecatedString("BinaryOperator::NotEqual"sv);
-break;}
-case 11 /* BitwiseAnd */: {
-return DeprecatedString("BinaryOperator::BitwiseAnd"sv);
-break;}
-case 12 /* BitwiseXor */: {
-return DeprecatedString("BinaryOperator::BitwiseXor"sv);
-break;}
-case 13 /* BitwiseOr */: {
-return DeprecatedString("BinaryOperator::BitwiseOr"sv);
-break;}
-case 14 /* BitwiseLeftShift */: {
-return DeprecatedString("BinaryOperator::BitwiseLeftShift"sv);
-break;}
-case 15 /* BitwiseRightShift */: {
-return DeprecatedString("BinaryOperator::BitwiseRightShift"sv);
-break;}
-case 16 /* ArithmeticLeftShift */: {
-return DeprecatedString("BinaryOperator::ArithmeticLeftShift"sv);
-break;}
-case 17 /* ArithmeticRightShift */: {
-return DeprecatedString("BinaryOperator::ArithmeticRightShift"sv);
-break;}
-case 18 /* LogicalAnd */: {
-return DeprecatedString("BinaryOperator::LogicalAnd"sv);
-break;}
-case 19 /* LogicalOr */: {
-return DeprecatedString("BinaryOperator::LogicalOr"sv);
-break;}
-case 20 /* NoneCoalescing */: {
-return DeprecatedString("BinaryOperator::NoneCoalescing"sv);
-break;}
-case 21 /* Assign */: {
-return DeprecatedString("BinaryOperator::Assign"sv);
-break;}
-case 22 /* BitwiseAndAssign */: {
-return DeprecatedString("BinaryOperator::BitwiseAndAssign"sv);
-break;}
-case 23 /* BitwiseOrAssign */: {
-return DeprecatedString("BinaryOperator::BitwiseOrAssign"sv);
-break;}
-case 24 /* BitwiseXorAssign */: {
-return DeprecatedString("BinaryOperator::BitwiseXorAssign"sv);
-break;}
-case 25 /* BitwiseLeftShiftAssign */: {
-return DeprecatedString("BinaryOperator::BitwiseLeftShiftAssign"sv);
-break;}
-case 26 /* BitwiseRightShiftAssign */: {
-return DeprecatedString("BinaryOperator::BitwiseRightShiftAssign"sv);
-break;}
-case 27 /* AddAssign */: {
-return DeprecatedString("BinaryOperator::AddAssign"sv);
-break;}
-case 28 /* SubtractAssign */: {
-return DeprecatedString("BinaryOperator::SubtractAssign"sv);
-break;}
-case 29 /* MultiplyAssign */: {
-return DeprecatedString("BinaryOperator::MultiplyAssign"sv);
-break;}
-case 30 /* ModuloAssign */: {
-return DeprecatedString("BinaryOperator::ModuloAssign"sv);
-break;}
-case 31 /* DivideAssign */: {
-return DeprecatedString("BinaryOperator::DivideAssign"sv);
-break;}
-case 32 /* NoneCoalescingAssign */: {
-return DeprecatedString("BinaryOperator::NoneCoalescingAssign"sv);
-break;}
-case 33 /* Garbage */: {
-return DeprecatedString("BinaryOperator::Garbage"sv);
+TRY(builder.append(")"sv));
 break;}
-}
-return builder.to_string();
-}
-bool parser::BinaryOperator::equals(parser::BinaryOperator const rhs_op) const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 0 /* Add */));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 1 /* Subtract */));
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 2 /* Multiply */));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 3 /* Divide */));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 4 /* Modulo */));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 5 /* LessThan */));
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 6 /* LessThanOrEqual */));
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 7 /* GreaterThan */));
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 8 /* GreaterThanOrEqual */));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 9 /* Equal */));
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 10 /* NotEqual */));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 11 /* BitwiseAnd */));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 12 /* BitwiseXor */));
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 13 /* BitwiseOr */));
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 14 /* BitwiseLeftShift */));
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 15 /* BitwiseRightShift */));
-};/*case end*/
-case 16: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 16 /* ArithmeticLeftShift */));
-};/*case end*/
-case 17: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 17 /* ArithmeticRightShift */));
-};/*case end*/
-case 19: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 19 /* LogicalOr */));
-};/*case end*/
-case 18: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 18 /* LogicalAnd */));
-};/*case end*/
-case 20: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 20 /* NoneCoalescing */));
-};/*case end*/
-case 21: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 21 /* Assign */));
-};/*case end*/
-case 22: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 22 /* BitwiseAndAssign */));
-};/*case end*/
-case 23: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 23 /* BitwiseOrAssign */));
-};/*case end*/
-case 24: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 24 /* BitwiseXorAssign */));
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 25 /* BitwiseLeftShiftAssign */));
-};/*case end*/
-case 26: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 26 /* BitwiseRightShiftAssign */));
-};/*case end*/
-case 27: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 27 /* AddAssign */));
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 28 /* SubtractAssign */));
-};/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 29 /* MultiplyAssign */));
-};/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 30 /* ModuloAssign */));
-};/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 31 /* DivideAssign */));
-};/*case end*/
-case 32: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 32 /* NoneCoalescingAssign */));
-};/*case end*/
-case 33: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 33 /* Garbage */));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-bool parser::BinaryOperator::is_assignment() const {
+case 6 /* IndexedTuple */: {
+TRY(builder.append("ParsedExpression::IndexedTuple"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::IndexedTuple>();
+TRY(builder.append("("sv));
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 21: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 22: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 23: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 24: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 26: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 27: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 29: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 32: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-}
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: {}", that.index));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-
-ErrorOr<DeprecatedString> parser::FunctionType::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Normal */: {
-return DeprecatedString("FunctionType::Normal"sv);
-break;}
-case 1 /* Destructor */: {
-return DeprecatedString("FunctionType::Destructor"sv);
-break;}
-case 2 /* ImplicitConstructor */: {
-return DeprecatedString("FunctionType::ImplicitConstructor"sv);
-break;}
-case 3 /* ImplicitEnumConstructor */: {
-return DeprecatedString("FunctionType::ImplicitEnumConstructor"sv);
-break;}
-case 4 /* ExternalClassConstructor */: {
-return DeprecatedString("FunctionType::ExternalClassConstructor"sv);
+TRY(builder.append(")"sv));
 break;}
-case 5 /* Expression */: {
-return DeprecatedString("FunctionType::Expression"sv);
+case 7 /* IndexedStruct */: {
+TRY(builder.append("ParsedExpression::IndexedStruct"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::IndexedStruct>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("field_name: \"{}\"", that.field_name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
 break;}
-case 6 /* Closure */: {
-return DeprecatedString("FunctionType::Closure"sv);
+case 8 /* ComptimeIndex */: {
+TRY(builder.append("ParsedExpression::ComptimeIndex"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::ComptimeIndex>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: {}", that.index));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
 break;}
+case 9 /* Var */: {
+TRY(builder.append("ParsedExpression::Var"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Var>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-return builder.to_string();
+TRY(builder.append(")"sv));
+break;}
+case 10 /* IndexedExpression */: {
+TRY(builder.append("ParsedExpression::IndexedExpression"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::IndexedExpression>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("base: {}", that.base));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: {}", that.index));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-ErrorOr<DeprecatedString> parser::ParsedStatement::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Expression */: {
-TRY(builder.append("ParsedStatement::Expression"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Expression>();
+TRY(builder.append(")"sv));
+break;}
+case 11 /* UnaryOp */: {
+TRY(builder.append("ParsedExpression::UnaryOp"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::UnaryOp>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
@@ -12788,154 +12182,233 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("expr: {}", that.expr));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("op: {}", that.op));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 1 /* Defer */: {
-TRY(builder.append("ParsedStatement::Defer"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Defer>();
+case 12 /* BinaryOp */: {
+TRY(builder.append("ParsedExpression::BinaryOp"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::BinaryOp>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("statement: {}", that.statement));
+TRY(builder.appendff("lhs: {}", that.lhs));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("op: {}", that.op));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("rhs: {}", that.rhs));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 2 /* UnsafeBlock */: {
-TRY(builder.append("ParsedStatement::UnsafeBlock"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::UnsafeBlock>();
+case 13 /* Operator */: {
+TRY(builder.append("ParsedExpression::Operator"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Operator>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("op: {}", that.op));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 3 /* DestructuringAssignment */: {
-TRY(builder.append("ParsedStatement::DestructuringAssignment"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::DestructuringAssignment>();
+case 14 /* OptionalSome */: {
+TRY(builder.append("ParsedExpression::OptionalSome"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::OptionalSome>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("vars: {}", that.vars));
+TRY(builder.appendff("expr: {}", that.expr));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("var_decl: {}", that.var_decl));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 15 /* OptionalNone */: {
+TRY(builder.append("ParsedExpression::OptionalNone"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::OptionalNone>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 16 /* JaktArray */: {
+TRY(builder.append("ParsedExpression::JaktArray"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::JaktArray>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("values: {}", that.values));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("fill_size: {}", that.fill_size));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 4 /* VarDecl */: {
-TRY(builder.append("ParsedStatement::VarDecl"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::VarDecl>();
+case 17 /* JaktDictionary */: {
+TRY(builder.append("ParsedExpression::JaktDictionary"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::JaktDictionary>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("var: {}", that.var));
+TRY(builder.appendff("values: {}", that.values));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("init: {}", that.init));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 18 /* Set */: {
+TRY(builder.append("ParsedExpression::Set"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Set>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("values: {}", that.values));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 5 /* If */: {
-TRY(builder.append("ParsedStatement::If"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::If>();
+case 19 /* JaktTuple */: {
+TRY(builder.append("ParsedExpression::JaktTuple"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::JaktTuple>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("condition: {}", that.condition));
+TRY(builder.appendff("values: {}", that.values));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("then_block: {}", that.then_block));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 20 /* Range */: {
+TRY(builder.append("ParsedExpression::Range"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Range>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("from: {}", that.from));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("else_statement: {}", that.else_statement));
+TRY(builder.appendff("to: {}", that.to));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 6 /* Block */: {
-TRY(builder.append("ParsedStatement::Block"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Block>();
+case 21 /* ForcedUnwrap */: {
+TRY(builder.append("ParsedExpression::ForcedUnwrap"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::ForcedUnwrap>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("expr: {}", that.expr));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 7 /* Loop */: {
-TRY(builder.append("ParsedStatement::Loop"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Loop>();
+case 22 /* Match */: {
+TRY(builder.append("ParsedExpression::Match"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Match>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("cases: {}", that.cases));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("marker_span: {}", that.marker_span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 8 /* While */: {
-TRY(builder.append("ParsedStatement::While"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::While>();
+case 23 /* EnumVariantArg */: {
+TRY(builder.append("ParsedExpression::EnumVariantArg"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::EnumVariantArg>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("condition: {}", that.condition));
+TRY(builder.appendff("expr: {}", that.expr));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("arg: {}", that.arg));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("enum_variant: {}", that.enum_variant));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 9 /* For */: {
-TRY(builder.append("ParsedStatement::For"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::For>();
+case 24 /* NamespacedVar */: {
+TRY(builder.append("ParsedExpression::NamespacedVar"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::NamespacedVar>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("namespace_: {}", that.namespace_));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 25 /* Function */: {
+TRY(builder.append("ParsedExpression::Function"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Function>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("iterator_name: \"{}\"", that.iterator_name));
+TRY(builder.appendff("captures: {}", that.captures));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("params: {}", that.params));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name_span: {}", that.name_span));
+TRY(builder.appendff("can_throw: {}", that.can_throw));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_destructuring: {}", that.is_destructuring));
+TRY(builder.appendff("is_fat_arrow: {}", that.is_fat_arrow));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("range: {}", that.range));
+TRY(builder.appendff("return_type: {}", that.return_type));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("block: {}", that.block));
@@ -12945,19 +12418,9 @@ TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 10 /* Break */: {
-TRY(builder.append("ParsedStatement::Break"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Break>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 11 /* Continue */: {
-TRY(builder.append("ParsedStatement::Continue"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Continue>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 12 /* Return */: {
-TRY(builder.append("ParsedStatement::Return"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Return>();
+case 26 /* Try */: {
+TRY(builder.append("ParsedExpression::Try"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Try>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
@@ -12965,93 +12428,272 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("expr: {}", that.expr));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 13 /* Throw */: {
-TRY(builder.append("ParsedStatement::Throw"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Throw>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(builder.appendff("catch_block: {}", that.catch_block));
+TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.appendff("catch_name: {}", that.catch_name));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 14 /* Yield */: {
-TRY(builder.append("ParsedStatement::Yield"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Yield>();
+case 27 /* TryBlock */: {
+TRY(builder.append("ParsedExpression::TryBlock"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::TryBlock>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.appendff("stmt: {}", that.stmt));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 15 /* InlineCpp */: {
-TRY(builder.append("ParsedStatement::InlineCpp"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::InlineCpp>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(builder.appendff("error_name: \"{}\"", that.error_name));
+TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("error_span: {}", that.error_span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("catch_block: {}", that.catch_block));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 16 /* Guard */: {
-TRY(builder.append("ParsedStatement::Guard"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Guard>();
+case 28 /* Reflect */: {
+TRY(builder.append("ParsedExpression::Reflect"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Reflect>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("else_block: {}", that.else_block));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("remaining_code: {}", that.remaining_code));
+TRY(builder.appendff("type: {}", that.type));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 17 /* Garbage */: {
-TRY(builder.append("ParsedStatement::Garbage"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Garbage>();
+case 29 /* Garbage */: {
+TRY(builder.append("ParsedExpression::Garbage"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedExpression::Garbage>();
 TRY(builder.appendff("({})", that.value));
 break;}
 }
 return builder.to_string();
 }
-bool parser::ParsedStatement::equals(NonnullRefPtr<typename parser::ParsedStatement> const rhs_statement) const {
+bool parser::ParsedExpression::equals(NonnullRefPtr<typename parser::ParsedExpression> const rhs_expression) const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Expression>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Boolean>();bool const& lhs_val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Boolean>();bool const& rhs_val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue((lhs_val == rhs_val));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NumericConstant>();parser::NumericConstant const& lhs_val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NumericConstant>();parser::NumericConstant const& rhs_val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue((((lhs_val).to_usize()) == ((rhs_val).to_usize())));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::QuotedString>();DeprecatedString const& lhs_val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::QuotedString>();DeprecatedString const& rhs_val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue((lhs_val == rhs_val));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::SingleQuotedString>();DeprecatedString const& lhs_val = __jakt_match_value.val;
+JaktInternal::Optional<DeprecatedString> const& lhs_prefix = __jakt_match_value.prefix;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::SingleQuotedString>();DeprecatedString const& rhs_val = __jakt_match_value.val;
+JaktInternal::Optional<DeprecatedString> const& rhs_prefix = __jakt_match_value.prefix;
+return JaktInternal::ExplicitValue(((lhs_val == rhs_val) && (lhs_prefix == rhs_prefix)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Call>();parser::ParsedCall const& lhs_call = __jakt_match_value.call;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Call>();parser::ParsedCall const& rhs_call = __jakt_match_value.call;
+return JaktInternal::ExplicitValue(((lhs_call).equals(rhs_call)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::MethodCall>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+parser::ParsedCall const& lhs_call = __jakt_match_value.call;
+bool const& lhs_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::MethodCall>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+parser::ParsedCall const& rhs_call = __jakt_match_value.call;
+bool const& rhs_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue((((lhs_optional == rhs_optional) && ((lhs_expr)->equals(rhs_expr))) && ((lhs_call).equals(rhs_call))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedTuple>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+size_t const& lhs_index = __jakt_match_value.index;
+bool const& lhs_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedTuple>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+size_t const& rhs_index = __jakt_match_value.index;
+bool const& rhs_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue((((lhs_optional == rhs_optional) && ((lhs_expr)->equals(rhs_expr))) && (lhs_index == rhs_index)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedStruct>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+DeprecatedString const& lhs_field = __jakt_match_value.field_name;
+bool const& lhs_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedStruct>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+DeprecatedString const& rhs_field = __jakt_match_value.field_name;
+bool const& rhs_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue((((lhs_optional == rhs_optional) && ((lhs_expr)->equals(rhs_expr))) && (lhs_field == rhs_field)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ComptimeIndex>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+NonnullRefPtr<typename parser::ParsedExpression> const& lhs_index = __jakt_match_value.index;
+bool const& lhs_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ComptimeIndex>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+NonnullRefPtr<typename parser::ParsedExpression> const& rhs_index = __jakt_match_value.index;
+bool const& rhs_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue((((lhs_optional == rhs_optional) && ((lhs_expr)->equals(rhs_expr))) && ((lhs_index)->equals(rhs_index))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();DeprecatedString const& lhs_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();DeprecatedString const& rhs_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue((lhs_name == rhs_name));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedExpression>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_base = __jakt_match_value.base;
+NonnullRefPtr<typename parser::ParsedExpression> const& lhs_index = __jakt_match_value.index;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedExpression>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_base = __jakt_match_value.base;
+NonnullRefPtr<typename parser::ParsedExpression> const& rhs_index = __jakt_match_value.index;
+return JaktInternal::ExplicitValue((((lhs_base)->equals(rhs_base)) && ((lhs_index)->equals(rhs_index))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+parser::UnaryOperator const& lhs_op = __jakt_match_value.op;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Expression>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+parser::UnaryOperator const& rhs_op = __jakt_match_value.op;
+return JaktInternal::ExplicitValue((((lhs_expr)->equals(rhs_expr)) && ((lhs_op).equals(rhs_op))));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13060,14 +12702,18 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Defer>();NonnullRefPtr<typename parser::ParsedStatement> const& lhs_statement = __jakt_match_value.statement;
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_lhs = __jakt_match_value.lhs;
+parser::BinaryOperator const& lhs_op = __jakt_match_value.op;
+NonnullRefPtr<typename parser::ParsedExpression> const& lhs_rhs = __jakt_match_value.rhs;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Defer>();NonnullRefPtr<typename parser::ParsedStatement> const& rhs_statement = __jakt_match_value.statement;
-return JaktInternal::ExplicitValue(((lhs_statement)->equals(rhs_statement)));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_lhs = __jakt_match_value.lhs;
+parser::BinaryOperator const& rhs_op = __jakt_match_value.op;
+NonnullRefPtr<typename parser::ParsedExpression> const& rhs_rhs = __jakt_match_value.rhs;
+return JaktInternal::ExplicitValue(((((lhs_lhs)->equals(rhs_lhs)) && ((lhs_op).equals(rhs_op))) && ((lhs_rhs)->equals(rhs_rhs))));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13076,14 +12722,14 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::UnsafeBlock>();parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& lhs_op = __jakt_match_value.op;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::UnsafeBlock>();parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(((lhs_block).equals(rhs_block)));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& rhs_op = __jakt_match_value.op;
+return JaktInternal::ExplicitValue(((lhs_op).equals(rhs_op)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13092,16 +12738,14 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::VarDecl>();parser::ParsedVarDecl const& lhs_var = __jakt_match_value.var;
-NonnullRefPtr<typename parser::ParsedExpression> const& lhs_init = __jakt_match_value.init;
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::OptionalSome>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::VarDecl>();parser::ParsedVarDecl const& rhs_var = __jakt_match_value.var;
-NonnullRefPtr<typename parser::ParsedExpression> const& rhs_init = __jakt_match_value.init;
-return JaktInternal::ExplicitValue((((lhs_var).equals(rhs_var)) && ((lhs_init)->equals(rhs_init))));
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::OptionalSome>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13110,21 +12754,91 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<parser::ParsedVarDecl> const& lhs_vars = __jakt_match_value.vars;
-NonnullRefPtr<typename parser::ParsedStatement> const& lhs_var_decl = __jakt_match_value.var_decl;
+case 15: {
+return JaktInternal::ExplicitValue(((rhs_expression)->index() == 15 /* OptionalNone */));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_values = __jakt_match_value.values;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_fill_size = __jakt_match_value.fill_size;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<parser::ParsedVarDecl> const& rhs_vars = __jakt_match_value.vars;
-NonnullRefPtr<typename parser::ParsedStatement> const& rhs_var_decl = __jakt_match_value.var_decl;
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_values = __jakt_match_value.values;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_fill_size = __jakt_match_value.fill_size;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_115; {
+if ((!(((lhs_fill_size).has_value())))){
+if (((rhs_fill_size).has_value())){
+return (false);
+}
+}
+else {
+if ((!(((rhs_fill_size).has_value())))){
+return (false);
+}
+if ((!((((lhs_fill_size.value()))->equals((rhs_fill_size.value())))))){
+return (false);
+}
+}
+
+__jakt_var_115 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
+auto __jakt_enum_value = ((((lhs_values).size()) == ((rhs_values).size())));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_116; {
 {
-if ((((lhs_vars).size()) != ((rhs_vars).size()))){
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_values).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if ((!(((((lhs_values)[i]))->equals(((rhs_values)[i])))))){
 return (false);
 }
+}
+
+}
+}
+
+__jakt_var_116 = true; goto __jakt_label_112;
+
+}
+__jakt_label_112:; __jakt_var_116.release_value(); }));
+}
+else {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_vars).size()))});
+return (false);
+}
+}
+}()))
+; goto __jakt_label_111;
+
+}
+__jakt_label_111:; __jakt_var_115.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const& lhs_values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const& rhs_values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_117; {
+__jakt_var_117 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
+auto __jakt_enum_value = ((((lhs_values).size()) == ((rhs_values).size())));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_118; {
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_values).size()))});
 for (;;){
 JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
@@ -13132,7 +12846,7 @@ break;
 }
 size_t i = (_magic_value.value());
 {
-if ((!(((((lhs_vars)[i])).equals(((rhs_vars)[i])))))){
+if ((!((((((((lhs_values)[i])).template get<0>()))->equals(((((rhs_values)[i])).template get<0>()))) && ((((((lhs_values)[i])).template get<1>()))->equals(((((rhs_values)[i])).template get<1>()))))))){
 return (false);
 }
 }
@@ -13140,11 +12854,21 @@ return (false);
 }
 }
 
-if ((!(((lhs_var_decl)->equals(rhs_var_decl))))){
+__jakt_var_118 = true; goto __jakt_label_114;
+
+}
+__jakt_label_114:; __jakt_var_118.release_value(); }));
+}
+else {
+{
 return (false);
 }
-return (true);
 }
+}()))
+; goto __jakt_label_113;
+
+}
+__jakt_label_113:; __jakt_var_117.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13153,35 +12877,102 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::If>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_condition = __jakt_match_value.condition;
-parser::ParsedBlock const& lhs_then_block = __jakt_match_value.then_block;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const& lhs_else_statement = __jakt_match_value.else_statement;
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Set>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_values = __jakt_match_value.values;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::If>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_condition = __jakt_match_value.condition;
-parser::ParsedBlock const& rhs_then_block = __jakt_match_value.then_block;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const& rhs_else_statement = __jakt_match_value.else_statement;
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Set>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_119; {
+__jakt_var_119 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
+auto __jakt_enum_value = ((((lhs_values).size()) == ((rhs_values).size())));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_120; {
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_values).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if ((!(((((lhs_values)[i]))->equals(((rhs_values)[i])))))){
+return (false);
+}
+}
+
+}
+}
+
+__jakt_var_120 = true; goto __jakt_label_116;
+
+}
+__jakt_label_116:; __jakt_var_120.release_value(); }));
+}
+else {
+{
+return (false);
+}
+}
+}()))
+; goto __jakt_label_115;
+
+}
+__jakt_label_115:; __jakt_var_119.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_expression;
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_121; {
+__jakt_var_121 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
+auto __jakt_enum_value = ((((lhs_values).size()) == ((rhs_values).size())));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_122; {
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_values).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
 {
-if ((!((((lhs_condition)->equals(rhs_condition)) && ((lhs_then_block).equals(rhs_then_block)))))){
+if ((!(((((lhs_values)[i]))->equals(((rhs_values)[i])))))){
 return (false);
 }
-if ((!(((lhs_else_statement).has_value())))){
-return ((!(((rhs_else_statement).has_value()))));
 }
-else {
-if ((!(((rhs_else_statement).has_value())))){
-return (false);
+
 }
-if ((((lhs_else_statement.value()))->equals((rhs_else_statement.value())))){
-return (true);
 }
+
+__jakt_var_122 = true; goto __jakt_label_118;
+
+}
+__jakt_label_118:; __jakt_var_122.release_value(); }));
+}
+else {
+{
 return (false);
 }
+}
+}()))
+; goto __jakt_label_117;
 
 }
+__jakt_label_117:; __jakt_var_121.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13190,14 +12981,30 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Block>();parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_from = __jakt_match_value.from;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_to = __jakt_match_value.to;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Block>();parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(((lhs_block).equals(rhs_block)));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_from = __jakt_match_value.from;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_to = __jakt_match_value.to;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_123; {
+bool equal = false;
+if (((((lhs_from).has_value()) == ((rhs_from).has_value())) && (((lhs_to).has_value()) == ((rhs_to).has_value())))){
+if ((((lhs_from).has_value()) && ((lhs_to).has_value()))){
+(equal = ((((lhs_from.value()))->equals((rhs_from.value()))) && (((lhs_to.value()))->equals((rhs_to.value())))));
+}
+else {
+(equal = true);
+}
+
+}
+__jakt_var_123 = equal; goto __jakt_label_119;
+
+}
+__jakt_label_119:; __jakt_var_123.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13206,14 +13013,14 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Loop>();parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ForcedUnwrap>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Loop>();parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(((lhs_block).equals(rhs_block)));
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ForcedUnwrap>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13222,16 +13029,63 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::While>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_condition = __jakt_match_value.condition;
-parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Match>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+JaktInternal::DynamicArray<parser::ParsedMatchCase> const& lhs_cases = __jakt_match_value.cases;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::While>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_condition = __jakt_match_value.condition;
-parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue((((lhs_condition)->equals(rhs_condition)) && ((lhs_block).equals(rhs_block))));
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Match>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+JaktInternal::DynamicArray<parser::ParsedMatchCase> const& rhs_cases = __jakt_match_value.cases;
+{
+if ((((lhs_expr)->equals(rhs_expr)) && (((lhs_cases).size()) == ((rhs_cases).size())))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_cases).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+bool current_case_has_match = false;
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((rhs_cases).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t k = (_magic_value.value());
+{
+if (((((lhs_cases)[i])).equals(((rhs_cases)[k])))){
+(current_case_has_match = true);
+break;
+}
+}
+
+}
+}
+
+if (current_case_has_match){
+}
+else {
+return (false);
+}
+
+}
+
+}
+}
+
+return (true);
+}
+else {
+return (false);
+}
+
+}
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13240,22 +13094,14 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::For>();DeprecatedString const& lhs_iterator_name = __jakt_match_value.iterator_name;
-NonnullRefPtr<typename parser::ParsedExpression> const& lhs_range = __jakt_match_value.range;
-parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::EnumVariantArg>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::For>();DeprecatedString const& rhs_iterator_name = __jakt_match_value.iterator_name;
-NonnullRefPtr<typename parser::ParsedExpression> const& rhs_range = __jakt_match_value.range;
-parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_122; {
-__jakt_var_122 = (((lhs_iterator_name == rhs_iterator_name) && ((lhs_range)->equals(rhs_range))) && ((lhs_block).equals(rhs_block))); goto __jakt_label_118;
-
-}
-__jakt_label_118:; __jakt_var_122.release_value(); }));
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::EnumVariantArg>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13264,34 +13110,40 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(((rhs_statement)->index() == 10 /* Break */));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(((rhs_statement)->index() == 11 /* Continue */));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_expr = __jakt_match_value.expr;
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NamespacedVar>();DeprecatedString const& lhs_name = __jakt_match_value.name;
+JaktInternal::DynamicArray<DeprecatedString> const& lhs_namespace = __jakt_match_value.namespace_;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_expr = __jakt_match_value.expr;
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NamespacedVar>();DeprecatedString const& rhs_name = __jakt_match_value.name;
+JaktInternal::DynamicArray<DeprecatedString> const& rhs_namespace = __jakt_match_value.namespace_;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_124; {
+if ((((lhs_namespace).size()) != ((rhs_namespace).size()))){
+return (false);
+}
 {
-if ((!(((lhs_expr).has_value())))){
-return ((!(((rhs_expr).has_value()))));
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_namespace).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-if ((!(((rhs_expr).has_value())))){
+size_t i = (_magic_value.value());
+{
+if ((((lhs_namespace)[i]) != ((rhs_namespace)[i]))){
 return (false);
 }
-if ((((lhs_expr.value()))->equals((rhs_expr.value())))){
-return (true);
 }
-return (false);
+
+}
 }
 
+__jakt_var_124 = (lhs_name == rhs_name); goto __jakt_label_120;
+
 }
+__jakt_label_120:; __jakt_var_124.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13300,14 +13152,36 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Throw>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Try>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+JaktInternal::Optional<parser::ParsedBlock> const& lhs_catch_block = __jakt_match_value.catch_block;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Throw>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Try>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+JaktInternal::Optional<parser::ParsedBlock> const& rhs_catch_block = __jakt_match_value.catch_block;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_125; {
+bool equals = ((lhs_expr)->equals(rhs_expr));
+if (equals){
+if (((lhs_catch_block).has_value())){
+if (((rhs_catch_block).has_value())){
+(equals = (((lhs_catch_block.value())).equals((rhs_catch_block.value()))));
+}
+else {
+(equals = false);
+}
+
+}
+else {
+(equals = (!(((rhs_catch_block).has_value()))));
+}
+
+}
+__jakt_var_125 = equals; goto __jakt_label_121;
+
+}
+__jakt_label_121:; __jakt_var_125.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13316,14 +13190,18 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::TryBlock>();NonnullRefPtr<typename parser::ParsedStatement> const& lhs_stmt = __jakt_match_value.stmt;
+DeprecatedString const& lhs_error_name = __jakt_match_value.error_name;
+parser::ParsedBlock const& lhs_catch_block = __jakt_match_value.catch_block;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::TryBlock>();NonnullRefPtr<typename parser::ParsedStatement> const& rhs_stmt = __jakt_match_value.stmt;
+DeprecatedString const& rhs_error_name = __jakt_match_value.error_name;
+parser::ParsedBlock const& rhs_catch_block = __jakt_match_value.catch_block;
+return JaktInternal::ExplicitValue(((((lhs_stmt)->equals(rhs_stmt)) && (lhs_error_name == rhs_error_name)) && ((lhs_catch_block).equals(rhs_catch_block))));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13332,14 +13210,62 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::InlineCpp>();parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Function>();JaktInternal::DynamicArray<parser::ParsedCapture> const& lhs_captures = __jakt_match_value.captures;
+JaktInternal::DynamicArray<parser::ParsedParameter> const& lhs_params = __jakt_match_value.params;
+bool const& lhs_can_throw = __jakt_match_value.can_throw;
+NonnullRefPtr<typename parser::ParsedType> const& lhs_return_type = __jakt_match_value.return_type;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::InlineCpp>();parser::ParsedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(((lhs_block).equals(block)));
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Function>();JaktInternal::DynamicArray<parser::ParsedCapture> const& rhs_captures = __jakt_match_value.captures;
+JaktInternal::DynamicArray<parser::ParsedParameter> const& rhs_params = __jakt_match_value.params;
+bool const& rhs_can_throw = __jakt_match_value.can_throw;
+NonnullRefPtr<typename parser::ParsedType> const& rhs_return_type = __jakt_match_value.return_type;
+{
+if ((((lhs_return_type)->equals(rhs_return_type)) && ((lhs_can_throw == rhs_can_throw) && ((((lhs_captures).size()) == ((rhs_captures).size())) && (((lhs_params).size()) == ((rhs_params).size())))))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_captures).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if ((!((((((lhs_captures)[i])).name()) == ((((rhs_captures)[i])).name()))))){
+return (false);
+}
+}
+
+}
+}
+
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_params).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if ((!(((((lhs_params)[i])).equals(((rhs_params)[i])))))){
+return (false);
+}
+}
+
+}
+}
+
+return (true);
+}
+else {
+return (false);
+}
+
+}
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13348,16 +13274,14 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
-parser::ParsedBlock const& lhs_else_block = __jakt_match_value.else_block;
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Reflect>();NonnullRefPtr<typename parser::ParsedType> const& type = __jakt_match_value.type;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_statement;
+auto&& __jakt_match_variant = *rhs_expression;
 switch(__jakt_match_variant.index()) {
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
-parser::ParsedBlock const& rhs_else_block = __jakt_match_value.else_block;
-return JaktInternal::ExplicitValue((((lhs_expr)->equals(rhs_expr)) && ((lhs_else_block).equals(rhs_else_block))));
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Reflect>();NonnullRefPtr<typename parser::ParsedType> const& rhs_type = __jakt_match_value.type;
+return JaktInternal::ExplicitValue(((type)->equals(rhs_type)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13366,8 +13290,8 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 17: {
-return JaktInternal::ExplicitValue(((rhs_statement)->index() == 17 /* Garbage */));
+case 29: {
+return JaktInternal::ExplicitValue(((rhs_expression)->index() == 29 /* Garbage */));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
@@ -13375,247 +13299,391 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-utility::Span parser::ParsedStatement::span() const {
+utility::Span parser::ParsedExpression::span() const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Expression>();utility::Span const& span = __jakt_match_value.span;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Boolean>();utility::Span const& span = __jakt_match_value.span;
 return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Defer>();utility::Span const& span = __jakt_match_value.span;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NumericConstant>();utility::Span const& span = __jakt_match_value.span;
 return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::UnsafeBlock>();utility::Span const& span = __jakt_match_value.span;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::QuotedString>();utility::Span const& span = __jakt_match_value.span;
 return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::DestructuringAssignment>();utility::Span const& span = __jakt_match_value.span;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::SingleQuotedString>();utility::Span const& span = __jakt_match_value.span;
 return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::VarDecl>();utility::Span const& span = __jakt_match_value.span;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Call>();utility::Span const& span = __jakt_match_value.span;
 return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::If>();utility::Span const& span = __jakt_match_value.span;
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::MethodCall>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedTuple>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedStruct>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ComptimeIndex>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedExpression>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::OptionalSome>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedExpression::OptionalNone>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktArray>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktDictionary>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Set>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktTuple>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Range>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ForcedUnwrap>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Match>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::EnumVariantArg>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NamespacedVar>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Function>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Try>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::TryBlock>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Reflect>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedExpression::Garbage>();
+utility::Span const& span = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Block>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
+i64 parser::ParsedExpression::precedence() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Operator>();parser::BinaryOperator const& op = __jakt_match_value.op;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue(static_cast<i64>(100LL));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(static_cast<i64>(100LL));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(static_cast<i64>(100LL));
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue(static_cast<i64>(90LL));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(static_cast<i64>(90LL));
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(static_cast<i64>(85LL));
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue(static_cast<i64>(85LL));
+};/*case end*/
+case 16: {
+return JaktInternal::ExplicitValue(static_cast<i64>(85LL));
+};/*case end*/
+case 17: {
+return JaktInternal::ExplicitValue(static_cast<i64>(85LL));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(static_cast<i64>(80LL));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(static_cast<i64>(73LL));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(static_cast<i64>(72LL));
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(static_cast<i64>(71LL));
+};/*case end*/
+case 18: {
+return JaktInternal::ExplicitValue(static_cast<i64>(70LL));
+};/*case end*/
+case 19: {
+return JaktInternal::ExplicitValue(static_cast<i64>(69LL));
+};/*case end*/
+case 20: {
+return JaktInternal::ExplicitValue(static_cast<i64>(69LL));
+};/*case end*/
+case 21: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
+};/*case end*/
+case 22: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
+};/*case end*/
+case 23: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Loop>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 24: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::While>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 25: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::For>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 26: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Break>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
+case 27: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Continue>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
+case 28: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Return>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 29: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Throw>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 30: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 31: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::InlineCpp>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 32: {
+return JaktInternal::ExplicitValue(static_cast<i64>(50LL));
 };/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+default: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
 };/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Garbage>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
+}/*switch end*/
+}()
+)));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+default: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+};/*case end*/
+}/*switch end*/
 }()
 )));
 }
 }
 
-ErrorOr<DeprecatedString> parser::ParsedMatchPattern::debug_description() const {
+ErrorOr<DeprecatedString> parser::FunctionLinkage::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* EnumVariant */: {
-TRY(builder.append("ParsedMatchPattern::EnumVariant"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedMatchPattern::EnumVariant>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("defaults: {}", that.defaults));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("variant_names: {}", that.variant_names));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("variant_arguments: {}", that.variant_arguments));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("arguments_span: {}", that.arguments_span));
+switch (this->index()) {case 0 /* Internal */: {
+return DeprecatedString("FunctionLinkage::Internal"sv);
+break;}
+case 1 /* External */: {
+return DeprecatedString("FunctionLinkage::External"sv);
+break;}
 }
-TRY(builder.append(")"sv));
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> parser::UnaryOperator::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* PreIncrement */: {
+return DeprecatedString("UnaryOperator::PreIncrement"sv);
 break;}
-case 1 /* Expression */: {
-TRY(builder.append("ParsedMatchPattern::Expression"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedMatchPattern::Expression>();
+case 1 /* PostIncrement */: {
+return DeprecatedString("UnaryOperator::PostIncrement"sv);
+break;}
+case 2 /* PreDecrement */: {
+return DeprecatedString("UnaryOperator::PreDecrement"sv);
+break;}
+case 3 /* PostDecrement */: {
+return DeprecatedString("UnaryOperator::PostDecrement"sv);
+break;}
+case 4 /* Negate */: {
+return DeprecatedString("UnaryOperator::Negate"sv);
+break;}
+case 5 /* Dereference */: {
+return DeprecatedString("UnaryOperator::Dereference"sv);
+break;}
+case 6 /* RawAddress */: {
+return DeprecatedString("UnaryOperator::RawAddress"sv);
+break;}
+case 7 /* Reference */: {
+return DeprecatedString("UnaryOperator::Reference"sv);
+break;}
+case 8 /* MutableReference */: {
+return DeprecatedString("UnaryOperator::MutableReference"sv);
+break;}
+case 9 /* LogicalNot */: {
+return DeprecatedString("UnaryOperator::LogicalNot"sv);
+break;}
+case 10 /* BitwiseNot */: {
+return DeprecatedString("UnaryOperator::BitwiseNot"sv);
+break;}
+case 11 /* TypeCast */: {
+TRY(builder.append("UnaryOperator::TypeCast"sv));
+[[maybe_unused]] auto const& that = this->template get<UnaryOperator::TypeCast>();
 TRY(builder.appendff("({})", that.value));
 break;}
-case 2 /* CatchAll */: {
-TRY(builder.append("ParsedMatchPattern::CatchAll"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedMatchPattern::CatchAll>();
+case 12 /* Is */: {
+TRY(builder.append("UnaryOperator::Is"sv));
+[[maybe_unused]] auto const& that = this->template get<UnaryOperator::Is>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 13 /* IsEnumVariant */: {
+TRY(builder.append("UnaryOperator::IsEnumVariant"sv));
+[[maybe_unused]] auto const& that = this->template get<UnaryOperator::IsEnumVariant>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("defaults: {}", that.defaults));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("variant_arguments: {}", that.variant_arguments));
+TRY(builder.appendff("inner: {}", that.inner));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("arguments_span: {}", that.arguments_span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 3 /* Invalid */: {
-return DeprecatedString("ParsedMatchPattern::Invalid"sv);
-break;}
-}
-return builder.to_string();
-}
-bool parser::ParsedMatchPattern::equals(parser::ParsedMatchPattern const rhs_parsed_match_pattern) const {
-{
-if (((*this).is_equal_pattern(rhs_parsed_match_pattern))){
-if (((*this).defaults_equal(((rhs_parsed_match_pattern).defaults())))){
-if (((*this).index() == 0 /* EnumVariant */)){
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const lhs_variant_arguments = ((*this).get<parser::ParsedMatchPattern::EnumVariant>()).variant_arguments;
-if (((rhs_parsed_match_pattern).index() == 0 /* EnumVariant */)){
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const rhs_variant_arguments = ((rhs_parsed_match_pattern).get<parser::ParsedMatchPattern::EnumVariant>()).variant_arguments;
-if ((((lhs_variant_arguments).size()) == ((rhs_variant_arguments).size()))){
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_variant_arguments).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if ((!(((((lhs_variant_arguments)[i])).equals(((rhs_variant_arguments)[i])))))){
-return (false);
-}
-}
-
-}
-}
-
-}
-else {
-return (false);
-}
-
-}
-else {
-return (false);
-}
-
-}
-return (true);
-}
-else {
-return (false);
-}
-
-}
-else {
-return (false);
-}
-
-}
-}
-
-bool parser::ParsedMatchPattern::is_equal_pattern(parser::ParsedMatchPattern const rhs_parsed_match_pattern) const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::EnumVariant>();JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const& lhs_variant_names = __jakt_match_value.variant_names;
-{
-if (((rhs_parsed_match_pattern).index() == 0 /* EnumVariant */)){
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const rhs_variant_names = ((rhs_parsed_match_pattern).get<parser::ParsedMatchPattern::EnumVariant>()).variant_names;
-size_t namespace_count = ((lhs_variant_names).size());
-if ((((rhs_variant_names).size()) < namespace_count)){
-(namespace_count = ((rhs_variant_names).size()));
-}
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(namespace_count)});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-DeprecatedString const lhs_name = ((((lhs_variant_names)[(JaktInternal::checked_sub<size_t>((JaktInternal::checked_sub<size_t>(((lhs_variant_names).size()),i)),static_cast<size_t>(1ULL)))])).template get<0>());
-DeprecatedString const rhs_name = ((((rhs_variant_names)[(JaktInternal::checked_sub<size_t>((JaktInternal::checked_sub<size_t>(((rhs_variant_names).size()),i)),static_cast<size_t>(1ULL)))])).template get<0>());
-if ((lhs_name == rhs_name)){
-}
-else {
-return (false);
-}
-
-}
-
-}
-}
-
-return (true);
-}
-else {
-return (false);
+TRY(builder.appendff("bindings: {}", that.bindings));
 }
-
+TRY(builder.append(")"sv));
+break;}
+case 14 /* Sizeof */: {
+TRY(builder.append("UnaryOperator::Sizeof"sv));
+[[maybe_unused]] auto const& that = this->template get<UnaryOperator::Sizeof>();
+TRY(builder.appendff("({})", that.value));
+break;}
 }
+return builder.to_string();
+}
+bool parser::UnaryOperator::equals(parser::UnaryOperator const rhs_op) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 0 /* PreIncrement */));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchPattern::Expression>();
-NonnullRefPtr<typename parser::ParsedExpression> const& lhs_parsed_expression = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((rhs_op).index() == 1 /* PostIncrement */));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 2 /* PreDecrement */));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 3 /* PostDecrement */));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 4 /* Negate */));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 5 /* Dereference */));
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 6 /* RawAddress */));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 7 /* Reference */));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 8 /* MutableReference */));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 9 /* LogicalNot */));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 10 /* BitwiseNot */));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::TypeCast>();
+parser::TypeCast const& lhs_type_cast = __jakt_match_value.value;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = rhs_parsed_match_pattern;
+auto&& __jakt_match_variant = rhs_op;
 switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchPattern::Expression>();
-NonnullRefPtr<typename parser::ParsedExpression> const& rhs_parsed_expression = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((lhs_parsed_expression)->equals(rhs_parsed_expression)));
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::TypeCast>();
+parser::TypeCast const& rhs_type_cast = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((lhs_type_cast).parsed_type()))->equals(((rhs_type_cast).parsed_type()))));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -13624,166 +13692,308 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(((rhs_parsed_match_pattern).index() == 2 /* CatchAll */));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Is>();
+NonnullRefPtr<typename parser::ParsedType> const& lhs_type = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = rhs_op;
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Is>();
+NonnullRefPtr<typename parser::ParsedType> const& rhs_type = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((lhs_type)->equals(rhs_type)));
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(((rhs_parsed_match_pattern).index() == 3 /* Invalid */));
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
-}
-}
-
-bool parser::ParsedMatchPattern::defaults_equal(JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const defaults) const {
-{
-if ((((defaults).size()) != ((((*this).defaults())).size()))){
-return (false);
-}
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Sizeof>();
+NonnullRefPtr<typename parser::ParsedType> const& lhs_type = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = rhs_op;
+switch(__jakt_match_variant.index()) {
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Sizeof>();
+NonnullRefPtr<typename parser::ParsedType> const& rhs_type = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((lhs_type)->equals(rhs_type)));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::UnaryOperator::IsEnumVariant>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner_type = __jakt_match_value.inner;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& lhs_bindings = __jakt_match_value.bindings;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = rhs_op;
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::UnaryOperator::IsEnumVariant>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner_type = __jakt_match_value.inner;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& rhs_bindings = __jakt_match_value.bindings;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_126; {
+bool equal = false;
+if ((((lhs_inner_type)->equals(rhs_inner_type)) && (((lhs_bindings).size()) == ((rhs_bindings).size())))){
+bool bindings_equal = true;
 {
-JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((*this).defaults())).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_bindings).size()))});
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> name__default___ = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt__name__default___ = name__default___;
-DeprecatedString const name = ((jakt__name__default___).template get<0>());
-parser::ParsedPatternDefault const default_ = ((jakt__name__default___).template get<1>());
-
-JaktInternal::Optional<parser::ParsedPatternDefault> const matching = ((defaults).get(name));
-if ((!(((matching).has_value())))){
-return (false);
+if ((!(((((lhs_bindings)[i])).equals(((rhs_bindings)[i])))))){
+(bindings_equal = false);
+break;
 }
-if ((!((((((matching.value())).value))->equals(((default_).value)))))){
-return (false);
 }
-if (((((((matching.value())).variable)).is_mutable) != ((((default_).variable)).is_mutable))){
-return (false);
+
 }
 }
 
+if (bindings_equal){
+(equal = true);
 }
 }
+__jakt_var_126 = equal; goto __jakt_label_122;
 
-return (true);
+}
+__jakt_label_122:; __jakt_var_126.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
 }
 
-ErrorOr<DeprecatedString> parser::FunctionLinkage::debug_description() const {
+ErrorOr<DeprecatedString> parser::BinaryOperator::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Internal */: {
-return DeprecatedString("FunctionLinkage::Internal"sv);
+switch (this->index()) {case 0 /* Add */: {
+return DeprecatedString("BinaryOperator::Add"sv);
 break;}
-case 1 /* External */: {
-return DeprecatedString("FunctionLinkage::External"sv);
+case 1 /* Subtract */: {
+return DeprecatedString("BinaryOperator::Subtract"sv);
+break;}
+case 2 /* Multiply */: {
+return DeprecatedString("BinaryOperator::Multiply"sv);
+break;}
+case 3 /* Divide */: {
+return DeprecatedString("BinaryOperator::Divide"sv);
+break;}
+case 4 /* Modulo */: {
+return DeprecatedString("BinaryOperator::Modulo"sv);
+break;}
+case 5 /* LessThan */: {
+return DeprecatedString("BinaryOperator::LessThan"sv);
+break;}
+case 6 /* LessThanOrEqual */: {
+return DeprecatedString("BinaryOperator::LessThanOrEqual"sv);
+break;}
+case 7 /* GreaterThan */: {
+return DeprecatedString("BinaryOperator::GreaterThan"sv);
+break;}
+case 8 /* GreaterThanOrEqual */: {
+return DeprecatedString("BinaryOperator::GreaterThanOrEqual"sv);
+break;}
+case 9 /* Equal */: {
+return DeprecatedString("BinaryOperator::Equal"sv);
+break;}
+case 10 /* NotEqual */: {
+return DeprecatedString("BinaryOperator::NotEqual"sv);
+break;}
+case 11 /* BitwiseAnd */: {
+return DeprecatedString("BinaryOperator::BitwiseAnd"sv);
+break;}
+case 12 /* BitwiseXor */: {
+return DeprecatedString("BinaryOperator::BitwiseXor"sv);
+break;}
+case 13 /* BitwiseOr */: {
+return DeprecatedString("BinaryOperator::BitwiseOr"sv);
+break;}
+case 14 /* BitwiseLeftShift */: {
+return DeprecatedString("BinaryOperator::BitwiseLeftShift"sv);
+break;}
+case 15 /* BitwiseRightShift */: {
+return DeprecatedString("BinaryOperator::BitwiseRightShift"sv);
+break;}
+case 16 /* ArithmeticLeftShift */: {
+return DeprecatedString("BinaryOperator::ArithmeticLeftShift"sv);
+break;}
+case 17 /* ArithmeticRightShift */: {
+return DeprecatedString("BinaryOperator::ArithmeticRightShift"sv);
+break;}
+case 18 /* LogicalAnd */: {
+return DeprecatedString("BinaryOperator::LogicalAnd"sv);
+break;}
+case 19 /* LogicalOr */: {
+return DeprecatedString("BinaryOperator::LogicalOr"sv);
+break;}
+case 20 /* NoneCoalescing */: {
+return DeprecatedString("BinaryOperator::NoneCoalescing"sv);
+break;}
+case 21 /* Assign */: {
+return DeprecatedString("BinaryOperator::Assign"sv);
+break;}
+case 22 /* BitwiseAndAssign */: {
+return DeprecatedString("BinaryOperator::BitwiseAndAssign"sv);
+break;}
+case 23 /* BitwiseOrAssign */: {
+return DeprecatedString("BinaryOperator::BitwiseOrAssign"sv);
+break;}
+case 24 /* BitwiseXorAssign */: {
+return DeprecatedString("BinaryOperator::BitwiseXorAssign"sv);
+break;}
+case 25 /* BitwiseLeftShiftAssign */: {
+return DeprecatedString("BinaryOperator::BitwiseLeftShiftAssign"sv);
+break;}
+case 26 /* BitwiseRightShiftAssign */: {
+return DeprecatedString("BinaryOperator::BitwiseRightShiftAssign"sv);
+break;}
+case 27 /* AddAssign */: {
+return DeprecatedString("BinaryOperator::AddAssign"sv);
+break;}
+case 28 /* SubtractAssign */: {
+return DeprecatedString("BinaryOperator::SubtractAssign"sv);
+break;}
+case 29 /* MultiplyAssign */: {
+return DeprecatedString("BinaryOperator::MultiplyAssign"sv);
+break;}
+case 30 /* ModuloAssign */: {
+return DeprecatedString("BinaryOperator::ModuloAssign"sv);
+break;}
+case 31 /* DivideAssign */: {
+return DeprecatedString("BinaryOperator::DivideAssign"sv);
 break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> parser::ImportName::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Literal */: {
-TRY(builder.append("ImportName::Literal"sv));
-[[maybe_unused]] auto const& that = this->template get<ImportName::Literal>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
+case 32 /* NoneCoalescingAssign */: {
+return DeprecatedString("BinaryOperator::NoneCoalescingAssign"sv);
 break;}
-case 1 /* Comptime */: {
-TRY(builder.append("ImportName::Comptime"sv));
-[[maybe_unused]] auto const& that = this->template get<ImportName::Comptime>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expression: {}", that.expression));
-}
-TRY(builder.append(")"sv));
+case 33 /* Garbage */: {
+return DeprecatedString("BinaryOperator::Garbage"sv);
 break;}
 }
 return builder.to_string();
 }
-DeprecatedString parser::ImportName::literal_name() const {
-{
-if (((*this).index() == 0 /* Literal */)){
-DeprecatedString const name = ((*this).get<parser::ImportName::Literal>()).name;
-return (name);
-}
-else {
-utility::panic(Jakt::DeprecatedString("Cannot get literal name of non-literal import name"sv));
-}
-
-}
-}
-
-bool parser::ImportName::equals(parser::ImportName const other) const {
+bool parser::BinaryOperator::equals(parser::BinaryOperator const rhs_op) const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Literal>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = other;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Literal>();DeprecatedString const& other_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue((name == other_name));
+return JaktInternal::ExplicitValue(((rhs_op).index() == 0 /* Add */));
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 1: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 1 /* Subtract */));
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 2: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 2 /* Multiply */));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Comptime>();NonnullRefPtr<typename parser::ParsedExpression> const& expression = __jakt_match_value.expression;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = other;
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Comptime>();NonnullRefPtr<typename parser::ParsedExpression> const& other_expression = __jakt_match_value.expression;
-return JaktInternal::ExplicitValue(((expression)->equals(other_expression)));
+case 3: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 3 /* Divide */));
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 4: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 4 /* Modulo */));
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 5: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 5 /* LessThan */));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-utility::Span parser::ImportName::span() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Literal>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 6: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 6 /* LessThanOrEqual */));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Comptime>();NonnullRefPtr<typename parser::ParsedExpression> const& expression = __jakt_match_value.expression;
-{
-return (((expression)->span()));
-}
+case 7: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 7 /* GreaterThan */));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 8 /* GreaterThanOrEqual */));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 9 /* Equal */));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 10 /* NotEqual */));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 11 /* BitwiseAnd */));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 12 /* BitwiseXor */));
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 13 /* BitwiseOr */));
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 14 /* BitwiseLeftShift */));
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 15 /* BitwiseRightShift */));
+};/*case end*/
+case 16: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 16 /* ArithmeticLeftShift */));
+};/*case end*/
+case 17: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 17 /* ArithmeticRightShift */));
+};/*case end*/
+case 19: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 19 /* LogicalOr */));
+};/*case end*/
+case 18: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 18 /* LogicalAnd */));
+};/*case end*/
+case 20: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 20 /* NoneCoalescing */));
+};/*case end*/
+case 21: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 21 /* Assign */));
+};/*case end*/
+case 22: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 22 /* BitwiseAndAssign */));
+};/*case end*/
+case 23: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 23 /* BitwiseOrAssign */));
+};/*case end*/
+case 24: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 24 /* BitwiseXorAssign */));
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 25 /* BitwiseLeftShiftAssign */));
+};/*case end*/
+case 26: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 26 /* BitwiseRightShiftAssign */));
+};/*case end*/
+case 27: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 27 /* AddAssign */));
+};/*case end*/
+case 28: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 28 /* SubtractAssign */));
+};/*case end*/
+case 29: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 29 /* MultiplyAssign */));
+};/*case end*/
+case 30: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 30 /* ModuloAssign */));
+};/*case end*/
+case 31: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 31 /* DivideAssign */));
+};/*case end*/
+case 32: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 32 /* NoneCoalescingAssign */));
+};/*case end*/
+case 33: {
+return JaktInternal::ExplicitValue(((rhs_op).index() == 33 /* Garbage */));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
@@ -13791,679 +14001,471 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-ErrorOr<DeprecatedString> parser::ParsedMatchBody::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Expression */: {
-TRY(builder.append("ParsedMatchBody::Expression"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedMatchBody::Expression>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* Block */: {
-TRY(builder.append("ParsedMatchBody::Block"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedMatchBody::Block>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-bool parser::ParsedMatchBody::equals(parser::ParsedMatchBody const rhs_match_body) const {
+bool parser::BinaryOperator::is_assignment() const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchBody::Expression>();
-NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_123; {
-__jakt_var_123 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
-auto __jakt_enum_value = (((rhs_match_body).index() == 0 /* Expression */));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_124; {
-NonnullRefPtr<typename parser::ParsedExpression> const rhs_expr = ((rhs_match_body).get<parser::ParsedMatchBody::Expression>()).value;
-__jakt_var_124 = ((lhs_expr)->equals(rhs_expr)); goto __jakt_label_120;
-
-}
-__jakt_label_120:; __jakt_var_124.release_value(); }));
-}
-else {
-{
-return (false);
-}
-}
-}()))
-; goto __jakt_label_119;
-
-}
-__jakt_label_119:; __jakt_var_123.release_value(); }));
+case 21: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 22: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 23: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 24: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 26: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 27: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 28: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 29: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 30: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 31: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 32: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchBody::Block>();
-parser::ParsedBlock const& lhs_block = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_125; {
-__jakt_var_125 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool,bool>{
-auto __jakt_enum_value = (((rhs_match_body).index() == 1 /* Block */));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_126; {
-parser::ParsedBlock const rhs_block = ((rhs_match_body).get<parser::ParsedMatchBody::Block>()).value;
-__jakt_var_126 = ((lhs_block).equals(rhs_block)); goto __jakt_label_122;
-
-}
-__jakt_label_122:; __jakt_var_126.release_value(); }));
-}
-else {
-{
-return (false);
-}
-}
-}()))
-; goto __jakt_label_121;
-
-}
-__jakt_label_121:; __jakt_var_125.release_value(); }));
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
 }
 }
 
-ErrorOr<DeprecatedString> parser::DefinitionLinkage::debug_description() const {
+ErrorOr<DeprecatedString> parser::NumericConstant::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Internal */: {
-return DeprecatedString("DefinitionLinkage::Internal"sv);
+switch (this->index()) {case 0 /* I8 */: {
+TRY(builder.append("NumericConstant::I8"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::I8>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 1 /* External */: {
-return DeprecatedString("DefinitionLinkage::External"sv);
+case 1 /* I16 */: {
+TRY(builder.append("NumericConstant::I16"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::I16>();
+TRY(builder.appendff("({})", that.value));
 break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> parser::RecordType::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Struct */: {
-TRY(builder.append("RecordType::Struct"sv));
-[[maybe_unused]] auto const& that = this->template get<RecordType::Struct>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("fields: {}", that.fields));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("super_type: {}", that.super_type));
-}
-TRY(builder.append(")"sv));
+case 2 /* I32 */: {
+TRY(builder.append("NumericConstant::I32"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::I32>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 1 /* Class */: {
-TRY(builder.append("RecordType::Class"sv));
-[[maybe_unused]] auto const& that = this->template get<RecordType::Class>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("fields: {}", that.fields));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("super_type: {}", that.super_type));
-}
-TRY(builder.append(")"sv));
+case 3 /* I64 */: {
+TRY(builder.append("NumericConstant::I64"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::I64>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 2 /* ValueEnum */: {
-TRY(builder.append("RecordType::ValueEnum"sv));
-[[maybe_unused]] auto const& that = this->template get<RecordType::ValueEnum>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("underlying_type: {}", that.underlying_type));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("variants: {}", that.variants));
-}
-TRY(builder.append(")"sv));
+case 4 /* U8 */: {
+TRY(builder.append("NumericConstant::U8"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::U8>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 3 /* SumEnum */: {
-TRY(builder.append("RecordType::SumEnum"sv));
-[[maybe_unused]] auto const& that = this->template get<RecordType::SumEnum>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_boxed: {}", that.is_boxed));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("fields: {}", that.fields));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("variants: {}", that.variants));
-}
-TRY(builder.append(")"sv));
+case 5 /* U16 */: {
+TRY(builder.append("NumericConstant::U16"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::U16>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 4 /* Garbage */: {
-return DeprecatedString("RecordType::Garbage"sv);
+case 6 /* U32 */: {
+TRY(builder.append("NumericConstant::U32"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::U32>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 7 /* U64 */: {
+TRY(builder.append("NumericConstant::U64"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::U64>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 8 /* USize */: {
+TRY(builder.append("NumericConstant::USize"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::USize>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 9 /* F32 */: {
+TRY(builder.append("NumericConstant::F32"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::F32>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 10 /* F64 */: {
+TRY(builder.append("NumericConstant::F64"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::F64>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 11 /* UnknownSigned */: {
+TRY(builder.append("NumericConstant::UnknownSigned"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::UnknownSigned>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 12 /* UnknownUnsigned */: {
+TRY(builder.append("NumericConstant::UnknownUnsigned"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericConstant::UnknownUnsigned>();
+TRY(builder.appendff("({})", that.value));
 break;}
 }
 return builder.to_string();
 }
-DeprecatedString parser::RecordType::record_type_name() const {
+size_t parser::NumericConstant::to_usize() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, DeprecatedString>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, size_t>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
 case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("struct"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I8>();
+i8 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
 };/*case end*/
 case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("class"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I16>();
+i16 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
 };/*case end*/
 case 2: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("value enum"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I32>();
+i32 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("sum enum"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I64>();
+i64 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
 };/*case end*/
 case 4: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("<garbage record type>"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U8>();
+u8 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U16>();
+u16 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U32>();
+u32 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U64>();
+u64 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::USize>();
+u64 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::UnknownSigned>();
+i64 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::UnknownUnsigned>();
+u64 const& num = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((static_cast<i64>(0LL)))));
+};/*case end*/
+}/*switch end*/
 }()
-)));
-}
-}
-
-ErrorOr<DeprecatedString> parser::Visibility::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Public */: {
-return DeprecatedString("Visibility::Public"sv);
-break;}
-case 1 /* Private */: {
-return DeprecatedString("Visibility::Private"sv);
-break;}
-case 2 /* Restricted */: {
-TRY(builder.append("Visibility::Restricted"sv));
-[[maybe_unused]] auto const& that = this->template get<Visibility::Restricted>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("whitelist: {}", that.whitelist));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> parser::ArgumentStoreLevel::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* InObject */: {
-TRY(builder.append("ArgumentStoreLevel::InObject"sv));
-[[maybe_unused]] auto const& that = this->template get<ArgumentStoreLevel::InObject>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("argument_index: {}", that.argument_index));
-}
-TRY(builder.append(")"sv));
-break;}
-case 1 /* InStaticStorage */: {
-return DeprecatedString("ArgumentStoreLevel::InStaticStorage"sv);
-break;}
+)));
 }
-return builder.to_string();
 }
-ErrorOr<DeprecatedString> parser::ParsedType::debug_description() const {
+
+ErrorOr<DeprecatedString> parser::ParsedStatement::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Name */: {
-TRY(builder.append("ParsedType::Name"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::Name>();
+switch (this->index()) {case 0 /* Expression */: {
+TRY(builder.append("ParsedStatement::Expression"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Expression>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.appendff("expr: {}", that.expr));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 1 /* NamespacedName */: {
-TRY(builder.append("ParsedType::NamespacedName"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::NamespacedName>();
+case 1 /* Defer */: {
+TRY(builder.append("ParsedStatement::Defer"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Defer>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("namespaces: {}", that.namespaces));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("params: {}", that.params));
+TRY(builder.appendff("statement: {}", that.statement));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 2 /* GenericType */: {
-TRY(builder.append("ParsedType::GenericType"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::GenericType>();
+case 2 /* UnsafeBlock */: {
+TRY(builder.append("ParsedStatement::UnsafeBlock"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::UnsafeBlock>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("generic_parameters: {}", that.generic_parameters));
+TRY(builder.appendff("block: {}", that.block));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 3 /* JaktArray */: {
-TRY(builder.append("ParsedType::JaktArray"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::JaktArray>();
+case 3 /* DestructuringAssignment */: {
+TRY(builder.append("ParsedStatement::DestructuringAssignment"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::DestructuringAssignment>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.appendff("vars: {}", that.vars));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("var_decl: {}", that.var_decl));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 4 /* Dictionary */: {
-TRY(builder.append("ParsedType::Dictionary"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::Dictionary>();
+case 4 /* VarDecl */: {
+TRY(builder.append("ParsedStatement::VarDecl"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::VarDecl>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("key: {}", that.key));
+TRY(builder.appendff("var: {}", that.var));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("value: {}", that.value));
+TRY(builder.appendff("init: {}", that.init));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 5 /* JaktTuple */: {
-TRY(builder.append("ParsedType::JaktTuple"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::JaktTuple>();
+case 5 /* If */: {
+TRY(builder.append("ParsedStatement::If"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::If>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("types: {}", that.types));
+TRY(builder.appendff("condition: {}", that.condition));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 6 /* Set */: {
-TRY(builder.append("ParsedType::Set"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::Set>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(builder.appendff("then_block: {}", that.then_block));
+TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.appendff("else_statement: {}", that.else_statement));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 7 /* Optional */: {
-TRY(builder.append("ParsedType::Optional"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::Optional>();
+case 6 /* Block */: {
+TRY(builder.append("ParsedStatement::Block"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Block>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.appendff("block: {}", that.block));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 8 /* Reference */: {
-TRY(builder.append("ParsedType::Reference"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::Reference>();
+case 7 /* Loop */: {
+TRY(builder.append("ParsedStatement::Loop"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Loop>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.appendff("block: {}", that.block));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 9 /* MutableReference */: {
-TRY(builder.append("ParsedType::MutableReference"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::MutableReference>();
+case 8 /* While */: {
+TRY(builder.append("ParsedStatement::While"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::While>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.appendff("condition: {}", that.condition));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 10 /* RawPtr */: {
-TRY(builder.append("ParsedType::RawPtr"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::RawPtr>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.appendff("block: {}", that.block));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 11 /* WeakPtr */: {
-TRY(builder.append("ParsedType::WeakPtr"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::WeakPtr>();
+case 9 /* For */: {
+TRY(builder.append("ParsedStatement::For"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::For>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner: {}", that.inner));
+TRY(builder.appendff("iterator_name: \"{}\"", that.iterator_name));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 12 /* Function */: {
-TRY(builder.append("ParsedType::Function"sv));
-[[maybe_unused]] auto const& that = this->template get<ParsedType::Function>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(builder.appendff("name_span: {}", that.name_span));
+TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("params: {}", that.params));
+TRY(builder.appendff("is_destructuring: {}", that.is_destructuring));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("can_throw: {}", that.can_throw));
+TRY(builder.appendff("range: {}", that.range));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("return_type: {}", that.return_type));
+TRY(builder.appendff("block: {}", that.block));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 13 /* Empty */: {
-return DeprecatedString("ParsedType::Empty"sv);
-break;}
-}
-return builder.to_string();
-}
-bool parser::ParsedType::equals(NonnullRefPtr<typename parser::ParsedType> const rhs_parsed_type) const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& lhs_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& rhs_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue((lhs_name == rhs_name));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& lhs_name = __jakt_match_value.name;
-JaktInternal::DynamicArray<DeprecatedString> const& lhs_namespaces = __jakt_match_value.namespaces;
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& lhs_params = __jakt_match_value.params;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& rhs_name = __jakt_match_value.name;
-JaktInternal::DynamicArray<DeprecatedString> const& rhs_namespaces = __jakt_match_value.namespaces;
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& rhs_params = __jakt_match_value.params;
-{
-if ((lhs_name != rhs_name)){
-return (false);
-}
-if ((((lhs_namespaces).size()) != ((rhs_namespaces).size()))){
-return (false);
-}
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_namespaces).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t namespace_index = (_magic_value.value());
-{
-if ((((lhs_namespaces)[namespace_index]) != ((rhs_namespaces)[namespace_index]))){
-return (false);
-}
-}
-
-}
-}
-
-if ((((lhs_params).size()) != ((rhs_params).size()))){
-return (false);
-}
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_params).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t param_index = (_magic_value.value());
-{
-if ((!(((((lhs_params)[param_index]))->equals(((rhs_params)[param_index])))))){
-return (false);
-}
-}
-
-}
-}
-
-return (true);
-}
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::GenericType>();DeprecatedString const& lhs_name = __jakt_match_value.name;
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& lhs_generic_parameters = __jakt_match_value.generic_parameters;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::GenericType>();DeprecatedString const& rhs_name = __jakt_match_value.name;
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& rhs_generic_parameters = __jakt_match_value.generic_parameters;
-{
-if ((lhs_name != rhs_name)){
-return (false);
-}
-if ((((lhs_generic_parameters).size()) != ((rhs_generic_parameters).size()))){
-return (false);
-}
+case 10 /* Break */: {
+TRY(builder.append("ParsedStatement::Break"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Break>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 11 /* Continue */: {
+TRY(builder.append("ParsedStatement::Continue"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Continue>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 12 /* Return */: {
+TRY(builder.append("ParsedStatement::Return"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Return>();
+TRY(builder.append("("sv));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_generic_parameters).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-size_t param_index = (_magic_value.value());
+TRY(builder.append(")"sv));
+break;}
+case 13 /* Throw */: {
+TRY(builder.append("ParsedStatement::Throw"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Throw>();
+TRY(builder.append("("sv));
 {
-if ((!(((((lhs_generic_parameters)[param_index]))->equals(((rhs_generic_parameters)[param_index])))))){
-return (false);
-}
-}
-
-}
-}
-
-return (true);
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktArray>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktArray>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Dictionary>();NonnullRefPtr<typename parser::ParsedType> const& lhs_key = __jakt_match_value.key;
-NonnullRefPtr<typename parser::ParsedType> const& lhs_value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
-switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Dictionary>();NonnullRefPtr<typename parser::ParsedType> const& rhs_key = __jakt_match_value.key;
-NonnullRefPtr<typename parser::ParsedType> const& rhs_value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((((lhs_key)->equals(rhs_key)) && ((lhs_value)->equals(rhs_value))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& lhs_types = __jakt_match_value.types;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& rhs_types = __jakt_match_value.types;
+TRY(builder.append(")"sv));
+break;}
+case 14 /* Yield */: {
+TRY(builder.append("ParsedStatement::Yield"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Yield>();
+TRY(builder.append("("sv));
 {
-if ((((lhs_types).size()) != ((rhs_types).size()))){
-return (false);
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
+TRY(builder.append(")"sv));
+break;}
+case 15 /* InlineCpp */: {
+TRY(builder.append("ParsedStatement::InlineCpp"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::InlineCpp>();
+TRY(builder.append("("sv));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_types).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("block: {}", that.block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-size_t type_index = (_magic_value.value());
+TRY(builder.append(")"sv));
+break;}
+case 16 /* Guard */: {
+TRY(builder.append("ParsedStatement::Guard"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Guard>();
+TRY(builder.append("("sv));
 {
-if ((!(((((lhs_types)[type_index]))->equals(((rhs_types)[type_index])))))){
-return (false);
-}
-}
-
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("else_block: {}", that.else_block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("remaining_code: {}", that.remaining_code));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
+TRY(builder.append(")"sv));
+break;}
+case 17 /* Garbage */: {
+TRY(builder.append("ParsedStatement::Garbage"sv));
+[[maybe_unused]] auto const& that = this->template get<ParsedStatement::Garbage>();
+TRY(builder.appendff("({})", that.value));
+break;}
 }
-
-return (true);
+return builder.to_string();
 }
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Set>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
-switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Set>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Optional>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
+bool parser::ParsedStatement::equals(NonnullRefPtr<typename parser::ParsedStatement> const rhs_statement) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Optional>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Reference>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Expression>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
+auto&& __jakt_match_variant = *rhs_statement;
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Reference>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Expression>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -14472,14 +14474,14 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::MutableReference>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Defer>();NonnullRefPtr<typename parser::ParsedStatement> const& lhs_statement = __jakt_match_value.statement;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
+auto&& __jakt_match_variant = *rhs_statement;
 switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::MutableReference>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Defer>();NonnullRefPtr<typename parser::ParsedStatement> const& rhs_statement = __jakt_match_value.statement;
+return JaktInternal::ExplicitValue(((lhs_statement)->equals(rhs_statement)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -14488,14 +14490,14 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::RawPtr>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::UnsafeBlock>();parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
+auto&& __jakt_match_variant = *rhs_statement;
 switch(__jakt_match_variant.index()) {
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::RawPtr>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::UnsafeBlock>();parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(((lhs_block).equals(rhs_block)));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -14504,14 +14506,16 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::WeakPtr>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner = __jakt_match_value.inner;
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::VarDecl>();parser::ParsedVarDecl const& lhs_var = __jakt_match_value.var;
+NonnullRefPtr<typename parser::ParsedExpression> const& lhs_init = __jakt_match_value.init;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
+auto&& __jakt_match_variant = *rhs_statement;
 switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::WeakPtr>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(((lhs_inner)->equals(rhs_inner)));
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::VarDecl>();parser::ParsedVarDecl const& rhs_var = __jakt_match_value.var;
+NonnullRefPtr<typename parser::ParsedExpression> const& rhs_init = __jakt_match_value.init;
+return JaktInternal::ExplicitValue((((lhs_var).equals(rhs_var)) && ((lhs_init)->equals(rhs_init))));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -14520,37 +14524,29 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Function>();JaktInternal::DynamicArray<parser::ParsedParameter> const& lhs_params = __jakt_match_value.params;
-bool const& lhs_can_throw = __jakt_match_value.can_throw;
-NonnullRefPtr<typename parser::ParsedType> const& lhs_return_type = __jakt_match_value.return_type;
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<parser::ParsedVarDecl> const& lhs_vars = __jakt_match_value.vars;
+NonnullRefPtr<typename parser::ParsedStatement> const& lhs_var_decl = __jakt_match_value.var_decl;
 return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *rhs_parsed_type;
+auto&& __jakt_match_variant = *rhs_statement;
 switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Function>();JaktInternal::DynamicArray<parser::ParsedParameter> const& rhs_params = __jakt_match_value.params;
-bool const& rhs_can_throw = __jakt_match_value.can_throw;
-NonnullRefPtr<typename parser::ParsedType> const& rhs_return_type = __jakt_match_value.return_type;
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<parser::ParsedVarDecl> const& rhs_vars = __jakt_match_value.vars;
+NonnullRefPtr<typename parser::ParsedStatement> const& rhs_var_decl = __jakt_match_value.var_decl;
 {
-if ((lhs_can_throw != rhs_can_throw)){
-return (false);
-}
-if ((!(((lhs_return_type)->equals(rhs_return_type))))){
-return (false);
-}
-if ((((lhs_params).size()) != ((rhs_params).size()))){
+if ((((lhs_vars).size()) != ((rhs_vars).size()))){
 return (false);
 }
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_params).size()))});
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((lhs_vars).size()))});
 for (;;){
 JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t param_index = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-if ((!(((((lhs_params)[param_index])).equals(((rhs_params)[param_index])))))){
+if ((!(((((lhs_vars)[i])).equals(((rhs_vars)[i])))))){
 return (false);
 }
 }
@@ -14558,6 +14554,9 @@ return (false);
 }
 }
 
+if ((!(((lhs_var_decl)->equals(rhs_var_decl))))){
+return (false);
+}
 return (true);
 }
 };/*case end*/
@@ -14568,461 +14567,436 @@ return JaktInternal::ExplicitValue(false);
 }()
 )));
 };/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(((rhs_parsed_type)->index() == 13 /* Empty */));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::If>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_condition = __jakt_match_value.condition;
+parser::ParsedBlock const& lhs_then_block = __jakt_match_value.then_block;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const& lhs_else_statement = __jakt_match_value.else_statement;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::If>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_condition = __jakt_match_value.condition;
+parser::ParsedBlock const& rhs_then_block = __jakt_match_value.then_block;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const& rhs_else_statement = __jakt_match_value.else_statement;
+{
+if ((!((((lhs_condition)->equals(rhs_condition)) && ((lhs_then_block).equals(rhs_then_block)))))){
+return (false);
+}
+if ((!(((lhs_else_statement).has_value())))){
+return ((!(((rhs_else_statement).has_value()))));
+}
+else {
+if ((!(((rhs_else_statement).has_value())))){
+return (false);
+}
+if ((((lhs_else_statement.value()))->equals((rhs_else_statement.value())))){
+return (true);
 }
+return (false);
 }
 
-utility::Span parser::ParsedType::span() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 13: {
-return JaktInternal::ExplicitValue(utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)));
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::GenericType>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktArray>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+}
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Dictionary>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktTuple>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+}/*switch end*/
+}()
+)));
 };/*case end*/
 case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Set>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Optional>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Reference>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::MutableReference>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::RawPtr>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::WeakPtr>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Block>();parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
+switch(__jakt_match_variant.index()) {
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Block>();parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(((lhs_block).equals(rhs_block)));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Function>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
-}
-}
-
-ErrorOr<DeprecatedString> parser::TypeCast::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Fallible */: {
-TRY(builder.append("TypeCast::Fallible"sv));
-[[maybe_unused]] auto const& that = this->template get<TypeCast::Fallible>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* Infallible */: {
-TRY(builder.append("TypeCast::Infallible"sv));
-[[maybe_unused]] auto const& that = this->template get<TypeCast::Infallible>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-NonnullRefPtr<typename parser::ParsedType> parser::TypeCast::parsed_type() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename parser::ParsedType>, NonnullRefPtr<typename parser::ParsedType>>{
-auto&& __jakt_match_variant = *this;
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Loop>();parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::TypeCast::Fallible>();
-NonnullRefPtr<typename parser::ParsedType> const& parsed_type = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(parsed_type);
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Loop>();parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(((lhs_block).equals(rhs_block)));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::TypeCast::Infallible>();
-NonnullRefPtr<typename parser::ParsedType> const& parsed_type = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(parsed_type);
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::While>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_condition = __jakt_match_value.condition;
+parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
+switch(__jakt_match_variant.index()) {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::While>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_condition = __jakt_match_value.condition;
+parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue((((lhs_condition)->equals(rhs_condition)) && ((lhs_block).equals(rhs_block))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::For>();DeprecatedString const& lhs_iterator_name = __jakt_match_value.iterator_name;
+NonnullRefPtr<typename parser::ParsedExpression> const& lhs_range = __jakt_match_value.range;
+parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::For>();DeprecatedString const& rhs_iterator_name = __jakt_match_value.iterator_name;
+NonnullRefPtr<typename parser::ParsedExpression> const& rhs_range = __jakt_match_value.range;
+parser::ParsedBlock const& rhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_127; {
+__jakt_var_127 = (((lhs_iterator_name == rhs_iterator_name) && ((lhs_range)->equals(rhs_range))) && ((lhs_block).equals(rhs_block))); goto __jakt_label_123;
+
 }
-}
-
-ErrorOr<DeprecatedString> parser::NumericConstant::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* I8 */: {
-TRY(builder.append("NumericConstant::I8"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::I8>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* I16 */: {
-TRY(builder.append("NumericConstant::I16"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::I16>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 2 /* I32 */: {
-TRY(builder.append("NumericConstant::I32"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::I32>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 3 /* I64 */: {
-TRY(builder.append("NumericConstant::I64"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::I64>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 4 /* U8 */: {
-TRY(builder.append("NumericConstant::U8"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::U8>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 5 /* U16 */: {
-TRY(builder.append("NumericConstant::U16"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::U16>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 6 /* U32 */: {
-TRY(builder.append("NumericConstant::U32"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::U32>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 7 /* U64 */: {
-TRY(builder.append("NumericConstant::U64"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::U64>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 8 /* USize */: {
-TRY(builder.append("NumericConstant::USize"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::USize>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 9 /* F32 */: {
-TRY(builder.append("NumericConstant::F32"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::F32>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 10 /* F64 */: {
-TRY(builder.append("NumericConstant::F64"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::F64>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 11 /* UnknownSigned */: {
-TRY(builder.append("NumericConstant::UnknownSigned"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::UnknownSigned>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 12 /* UnknownUnsigned */: {
-TRY(builder.append("NumericConstant::UnknownUnsigned"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericConstant::UnknownUnsigned>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-size_t parser::NumericConstant::to_usize() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, size_t>{
-auto&& __jakt_match_variant = *this;
+__jakt_label_123:; __jakt_var_127.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(((rhs_statement)->index() == 10 /* Break */));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(((rhs_statement)->index() == 11 /* Continue */));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& lhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I8>();
-i8 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& rhs_expr = __jakt_match_value.expr;
+{
+if ((!(((lhs_expr).has_value())))){
+return ((!(((rhs_expr).has_value()))));
+}
+else {
+if ((!(((rhs_expr).has_value())))){
+return (false);
+}
+if ((((lhs_expr.value()))->equals((rhs_expr.value())))){
+return (true);
+}
+return (false);
+}
+
+}
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I16>();
-i16 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I32>();
-i32 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I64>();
-i64 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Throw>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Throw>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U8>();
-u8 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U16>();
-u16 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U32>();
-u32 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
+switch(__jakt_match_variant.index()) {
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((lhs_expr)->equals(rhs_expr)));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U64>();
-u64 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::USize>();
-u64 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::UnknownSigned>();
-i64 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::InlineCpp>();parser::ParsedBlock const& lhs_block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
+switch(__jakt_match_variant.index()) {
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::InlineCpp>();parser::ParsedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(((lhs_block).equals(block)));
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::UnknownUnsigned>();
-u64 const& num = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((num))));
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs_expr = __jakt_match_value.expr;
+parser::ParsedBlock const& lhs_else_block = __jakt_match_value.else_block;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *rhs_statement;
+switch(__jakt_match_variant.index()) {
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();NonnullRefPtr<typename parser::ParsedExpression> const& rhs_expr = __jakt_match_value.expr;
+parser::ParsedBlock const& rhs_else_block = __jakt_match_value.else_block;
+return JaktInternal::ExplicitValue((((lhs_expr)->equals(rhs_expr)) && ((lhs_else_block).equals(rhs_else_block))));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((static_cast<i64>(0LL)))));
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
 }/*switch end*/
 }()
 )));
+};/*case end*/
+case 17: {
+return JaktInternal::ExplicitValue(((rhs_statement)->index() == 17 /* Garbage */));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
 }
 
-ErrorOr<DeprecatedString> parser::UnaryOperator::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* PreIncrement */: {
-return DeprecatedString("UnaryOperator::PreIncrement"sv);
-break;}
-case 1 /* PostIncrement */: {
-return DeprecatedString("UnaryOperator::PostIncrement"sv);
-break;}
-case 2 /* PreDecrement */: {
-return DeprecatedString("UnaryOperator::PreDecrement"sv);
-break;}
-case 3 /* PostDecrement */: {
-return DeprecatedString("UnaryOperator::PostDecrement"sv);
-break;}
-case 4 /* Negate */: {
-return DeprecatedString("UnaryOperator::Negate"sv);
-break;}
-case 5 /* Dereference */: {
-return DeprecatedString("UnaryOperator::Dereference"sv);
-break;}
-case 6 /* RawAddress */: {
-return DeprecatedString("UnaryOperator::RawAddress"sv);
-break;}
-case 7 /* Reference */: {
-return DeprecatedString("UnaryOperator::Reference"sv);
-break;}
-case 8 /* MutableReference */: {
-return DeprecatedString("UnaryOperator::MutableReference"sv);
-break;}
-case 9 /* LogicalNot */: {
-return DeprecatedString("UnaryOperator::LogicalNot"sv);
-break;}
-case 10 /* BitwiseNot */: {
-return DeprecatedString("UnaryOperator::BitwiseNot"sv);
-break;}
-case 11 /* TypeCast */: {
-TRY(builder.append("UnaryOperator::TypeCast"sv));
-[[maybe_unused]] auto const& that = this->template get<UnaryOperator::TypeCast>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 12 /* Is */: {
-TRY(builder.append("UnaryOperator::Is"sv));
-[[maybe_unused]] auto const& that = this->template get<UnaryOperator::Is>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 13 /* IsEnumVariant */: {
-TRY(builder.append("UnaryOperator::IsEnumVariant"sv));
-[[maybe_unused]] auto const& that = this->template get<UnaryOperator::IsEnumVariant>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner: {}", that.inner));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("bindings: {}", that.bindings));
-}
-TRY(builder.append(")"sv));
-break;}
-case 14 /* Sizeof */: {
-TRY(builder.append("UnaryOperator::Sizeof"sv));
-[[maybe_unused]] auto const& that = this->template get<UnaryOperator::Sizeof>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-bool parser::UnaryOperator::equals(parser::UnaryOperator const rhs_op) const {
+utility::Span parser::ParsedStatement::span() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
 case 0: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 0 /* PreIncrement */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Expression>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 1: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 1 /* PostIncrement */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Defer>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 2: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 2 /* PreDecrement */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::UnsafeBlock>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 3 /* PostDecrement */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::DestructuringAssignment>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 4: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 4 /* Negate */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::VarDecl>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 5 /* Dereference */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::If>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 6: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 6 /* RawAddress */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Block>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 7 /* Reference */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Loop>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 8: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 8 /* MutableReference */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::While>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 9: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 9 /* LogicalNot */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::For>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 10: {
-return JaktInternal::ExplicitValue(((rhs_op).index() == 10 /* BitwiseNot */));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Break>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::TypeCast>();
-parser::TypeCast const& lhs_type_cast = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = rhs_op;
-switch(__jakt_match_variant.index()) {
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::TypeCast>();
-parser::TypeCast const& rhs_type_cast = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((((lhs_type_cast).parsed_type()))->equals(((rhs_type_cast).parsed_type()))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Continue>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Is>();
-NonnullRefPtr<typename parser::ParsedType> const& lhs_type = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = rhs_op;
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Is>();
-NonnullRefPtr<typename parser::ParsedType> const& rhs_type = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((lhs_type)->equals(rhs_type)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Return>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Throw>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Sizeof>();
-NonnullRefPtr<typename parser::ParsedType> const& lhs_type = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = rhs_op;
-switch(__jakt_match_variant.index()) {
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Sizeof>();
-NonnullRefPtr<typename parser::ParsedType> const& rhs_type = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((lhs_type)->equals(rhs_type)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::InlineCpp>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-}/*switch end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Garbage>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::UnaryOperator::IsEnumVariant>();NonnullRefPtr<typename parser::ParsedType> const& lhs_inner_type = __jakt_match_value.inner;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& lhs_bindings = __jakt_match_value.bindings;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = rhs_op;
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::UnaryOperator::IsEnumVariant>();NonnullRefPtr<typename parser::ParsedType> const& rhs_inner_type = __jakt_match_value.inner;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& rhs_bindings = __jakt_match_value.bindings;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_127; {
-bool equal = false;
-if ((((lhs_inner_type)->equals(rhs_inner_type)) && (((lhs_bindings).size()) == ((rhs_bindings).size())))){
-bool bindings_equal = true;
+}
+}
+
+ErrorOr<DeprecatedString> parser::IncludeAction::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Define */: {
+TRY(builder.append("IncludeAction::Define"sv));
+[[maybe_unused]] auto const& that = this->template get<IncludeAction::Define>();
+TRY(builder.append("("sv));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_bindings).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("value: \"{}\"", that.value));
 }
-size_t i = (_magic_value.value());
+TRY(builder.append(")"sv));
+break;}
+case 1 /* Undefine */: {
+TRY(builder.append("IncludeAction::Undefine"sv));
+[[maybe_unused]] auto const& that = this->template get<IncludeAction::Undefine>();
+TRY(builder.append("("sv));
 {
-if ((!(((((lhs_bindings)[i])).equals(((rhs_bindings)[i])))))){
-(bindings_equal = false);
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
+TRY(builder.append(")"sv));
+break;}
 }
-
+return builder.to_string();
 }
+ErrorOr<DeprecatedString> parser::RecordType::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Struct */: {
+TRY(builder.append("RecordType::Struct"sv));
+[[maybe_unused]] auto const& that = this->template get<RecordType::Struct>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("fields: {}", that.fields));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("super_type: {}", that.super_type));
 }
-
-if (bindings_equal){
-(equal = true);
+TRY(builder.append(")"sv));
+break;}
+case 1 /* Class */: {
+TRY(builder.append("RecordType::Class"sv));
+[[maybe_unused]] auto const& that = this->template get<RecordType::Class>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("fields: {}", that.fields));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("super_type: {}", that.super_type));
 }
+TRY(builder.append(")"sv));
+break;}
+case 2 /* ValueEnum */: {
+TRY(builder.append("RecordType::ValueEnum"sv));
+[[maybe_unused]] auto const& that = this->template get<RecordType::ValueEnum>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("underlying_type: {}", that.underlying_type));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("variants: {}", that.variants));
 }
-__jakt_var_127 = equal; goto __jakt_label_123;
-
+TRY(builder.append(")"sv));
+break;}
+case 3 /* SumEnum */: {
+TRY(builder.append("RecordType::SumEnum"sv));
+[[maybe_unused]] auto const& that = this->template get<RecordType::SumEnum>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_boxed: {}", that.is_boxed));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("fields: {}", that.fields));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("variants: {}", that.variants));
 }
-__jakt_label_123:; __jakt_var_127.release_value(); }));
+TRY(builder.append(")"sv));
+break;}
+case 4 /* Garbage */: {
+return DeprecatedString("RecordType::Garbage"sv);
+break;}
+}
+return builder.to_string();
+}
+DeprecatedString parser::RecordType::record_type_name() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, DeprecatedString>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("struct"sv));
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 1: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("class"sv));
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 2: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("value enum"sv));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("sum enum"sv));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("<garbage record type>"sv));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
@@ -15030,5 +15004,31 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
+ErrorOr<DeprecatedString> parser::FunctionType::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Normal */: {
+return DeprecatedString("FunctionType::Normal"sv);
+break;}
+case 1 /* Destructor */: {
+return DeprecatedString("FunctionType::Destructor"sv);
+break;}
+case 2 /* ImplicitConstructor */: {
+return DeprecatedString("FunctionType::ImplicitConstructor"sv);
+break;}
+case 3 /* ImplicitEnumConstructor */: {
+return DeprecatedString("FunctionType::ImplicitEnumConstructor"sv);
+break;}
+case 4 /* ExternalClassConstructor */: {
+return DeprecatedString("FunctionType::ExternalClassConstructor"sv);
+break;}
+case 5 /* Expression */: {
+return DeprecatedString("FunctionType::Expression"sv);
+break;}
+case 6 /* Closure */: {
+return DeprecatedString("FunctionType::Closure"sv);
+break;}
+}
+return builder.to_string();
+}
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/parser.h b/bootstrap/stage0/parser.h
index 95d830038..9c3419ac2 100644
--- a/bootstrap/stage0/parser.h
+++ b/bootstrap/stage0/parser.h
@@ -8,10 +8,10 @@ namespace Jakt {
 namespace parser {
 struct ParsedBlock {
   public:
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> stmts;bool equals(parser::ParsedBlock const rhs_block) const;
-ParsedBlock(JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> a_stmts);
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> stmts;ParsedBlock(JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> a_stmts);
 
 JaktInternal::Optional<utility::Span> find_yield_span() const;
+bool equals(parser::ParsedBlock const rhs_block) const;
 ErrorOr<JaktInternal::Optional<utility::Span>> span(parser::Parser const parser) const;
 JaktInternal::Optional<utility::Span> find_yield_keyword_span() const;
 ErrorOr<DeprecatedString> debug_description() const;
@@ -45,128 +45,286 @@ bool equals(parser::ParsedMatchCase const rhs_match_case) const;
 ParsedMatchCase(JaktInternal::DynamicArray<parser::ParsedMatchPattern> a_patterns, utility::Span a_marker_span, parser::ParsedMatchBody a_body);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedVarDecl {
+};struct ValueEnumVariant {
   public:
-DeprecatedString name;NonnullRefPtr<typename parser::ParsedType> parsed_type;bool is_mutable;JaktInternal::Optional<utility::Span> inlay_span;utility::Span span;ParsedVarDecl(DeprecatedString a_name, NonnullRefPtr<typename parser::ParsedType> a_parsed_type, bool a_is_mutable, JaktInternal::Optional<utility::Span> a_inlay_span, utility::Span a_span);
+DeprecatedString name;utility::Span span;JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> value;ValueEnumVariant(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_value);
 
-bool equals(parser::ParsedVarDecl const rhs_var_decl) const;
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace NumericConstant_Details {
-struct I8{
-i8 value;
-template<typename _MemberT0>
-I8(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+};namespace ParsedMatchPattern_Details {
+struct EnumVariant {
+JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults;
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> variant_names;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments;
+utility::Span arguments_span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+EnumVariant(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+defaults{ forward<_MemberT0>(member_0)},
+variant_names{ forward<_MemberT1>(member_1)},
+variant_arguments{ forward<_MemberT2>(member_2)},
+arguments_span{ forward<_MemberT3>(member_3)}
 {}
 };
-struct I16{
-i16 value;
-template<typename _MemberT0>
-I16(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct Expression{
+JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults;
+NonnullRefPtr<typename parser::ParsedExpression> value;
+template<typename _MemberT0, typename _MemberT1>
+Expression(_MemberT0&& member_0, _MemberT1&& member_1):
+defaults{ forward<_MemberT0>(member_0)},
+value{ forward<_MemberT1>(member_1)}
 {}
 };
-struct I32{
-i32 value;
-template<typename _MemberT0>
-I32(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct CatchAll {
+JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments;
+utility::Span arguments_span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+CatchAll(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+defaults{ forward<_MemberT0>(member_0)},
+variant_arguments{ forward<_MemberT1>(member_1)},
+arguments_span{ forward<_MemberT2>(member_2)}
 {}
 };
-struct I64{
-i64 value;
+struct Invalid {
+JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults;
 template<typename _MemberT0>
-I64(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+Invalid(_MemberT0&& member_0):
+defaults{ forward<_MemberT0>(member_0)}
 {}
 };
-struct U8{
-u8 value;
-template<typename _MemberT0>
-U8(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+}
+struct ParsedMatchPattern : public Variant<ParsedMatchPattern_Details::EnumVariant, ParsedMatchPattern_Details::Expression, ParsedMatchPattern_Details::CatchAll, ParsedMatchPattern_Details::Invalid> {
+using Variant<ParsedMatchPattern_Details::EnumVariant, ParsedMatchPattern_Details::Expression, ParsedMatchPattern_Details::CatchAll, ParsedMatchPattern_Details::Invalid>::Variant;
+    using EnumVariant = ParsedMatchPattern_Details::EnumVariant;
+    using Expression = ParsedMatchPattern_Details::Expression;
+    using CatchAll = ParsedMatchPattern_Details::CatchAll;
+    using Invalid = ParsedMatchPattern_Details::Invalid;
+ErrorOr<DeprecatedString> debug_description() const;
+JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const& defaults() const { switch(this->index()) {case 0 /* EnumVariant */: return this->template get<ParsedMatchPattern::EnumVariant>().defaults;
+case 1 /* Expression */: return this->template get<ParsedMatchPattern::Expression>().defaults;
+case 2 /* CatchAll */: return this->template get<ParsedMatchPattern::CatchAll>().defaults;
+case 3 /* Invalid */: return this->template get<ParsedMatchPattern::Invalid>().defaults;
+default: VERIFY_NOT_REACHED();
+}
+}
+bool equals(parser::ParsedMatchPattern const rhs_parsed_match_pattern) const;
+bool is_equal_pattern(parser::ParsedMatchPattern const rhs_parsed_match_pattern) const;
+bool defaults_equal(JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const defaults) const;
 };
-struct U16{
-u16 value;
-template<typename _MemberT0>
-U16(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+struct ParsedTrait {
+  public:
+DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<parser::ParsedGenericParameter> generic_parameters;JaktInternal::DynamicArray<parser::ParsedFunction> methods;ParsedTrait(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<parser::ParsedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<parser::ParsedFunction> a_methods);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace BinaryOperator_Details {
+struct Add {
 };
-struct U32{
-u32 value;
-template<typename _MemberT0>
-U32(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+struct Subtract {
 };
-struct U64{
-u64 value;
-template<typename _MemberT0>
-U64(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+struct Multiply {
 };
-struct USize{
-u64 value;
-template<typename _MemberT0>
-USize(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct Divide {
+};
+struct Modulo {
+};
+struct LessThan {
+};
+struct LessThanOrEqual {
+};
+struct GreaterThan {
+};
+struct GreaterThanOrEqual {
+};
+struct Equal {
+};
+struct NotEqual {
+};
+struct BitwiseAnd {
+};
+struct BitwiseXor {
+};
+struct BitwiseOr {
+};
+struct BitwiseLeftShift {
+};
+struct BitwiseRightShift {
+};
+struct ArithmeticLeftShift {
+};
+struct ArithmeticRightShift {
+};
+struct LogicalAnd {
+};
+struct LogicalOr {
+};
+struct NoneCoalescing {
+};
+struct Assign {
+};
+struct BitwiseAndAssign {
+};
+struct BitwiseOrAssign {
+};
+struct BitwiseXorAssign {
+};
+struct BitwiseLeftShiftAssign {
+};
+struct BitwiseRightShiftAssign {
+};
+struct AddAssign {
+};
+struct SubtractAssign {
+};
+struct MultiplyAssign {
+};
+struct ModuloAssign {
+};
+struct DivideAssign {
+};
+struct NoneCoalescingAssign {
+};
+struct Garbage {
+};
+}
+struct BinaryOperator : public Variant<BinaryOperator_Details::Add, BinaryOperator_Details::Subtract, BinaryOperator_Details::Multiply, BinaryOperator_Details::Divide, BinaryOperator_Details::Modulo, BinaryOperator_Details::LessThan, BinaryOperator_Details::LessThanOrEqual, BinaryOperator_Details::GreaterThan, BinaryOperator_Details::GreaterThanOrEqual, BinaryOperator_Details::Equal, BinaryOperator_Details::NotEqual, BinaryOperator_Details::BitwiseAnd, BinaryOperator_Details::BitwiseXor, BinaryOperator_Details::BitwiseOr, BinaryOperator_Details::BitwiseLeftShift, BinaryOperator_Details::BitwiseRightShift, BinaryOperator_Details::ArithmeticLeftShift, BinaryOperator_Details::ArithmeticRightShift, BinaryOperator_Details::LogicalAnd, BinaryOperator_Details::LogicalOr, BinaryOperator_Details::NoneCoalescing, BinaryOperator_Details::Assign, BinaryOperator_Details::BitwiseAndAssign, BinaryOperator_Details::BitwiseOrAssign, BinaryOperator_Details::BitwiseXorAssign, BinaryOperator_Details::BitwiseLeftShiftAssign, BinaryOperator_Details::BitwiseRightShiftAssign, BinaryOperator_Details::AddAssign, BinaryOperator_Details::SubtractAssign, BinaryOperator_Details::MultiplyAssign, BinaryOperator_Details::ModuloAssign, BinaryOperator_Details::DivideAssign, BinaryOperator_Details::NoneCoalescingAssign, BinaryOperator_Details::Garbage> {
+using Variant<BinaryOperator_Details::Add, BinaryOperator_Details::Subtract, BinaryOperator_Details::Multiply, BinaryOperator_Details::Divide, BinaryOperator_Details::Modulo, BinaryOperator_Details::LessThan, BinaryOperator_Details::LessThanOrEqual, BinaryOperator_Details::GreaterThan, BinaryOperator_Details::GreaterThanOrEqual, BinaryOperator_Details::Equal, BinaryOperator_Details::NotEqual, BinaryOperator_Details::BitwiseAnd, BinaryOperator_Details::BitwiseXor, BinaryOperator_Details::BitwiseOr, BinaryOperator_Details::BitwiseLeftShift, BinaryOperator_Details::BitwiseRightShift, BinaryOperator_Details::ArithmeticLeftShift, BinaryOperator_Details::ArithmeticRightShift, BinaryOperator_Details::LogicalAnd, BinaryOperator_Details::LogicalOr, BinaryOperator_Details::NoneCoalescing, BinaryOperator_Details::Assign, BinaryOperator_Details::BitwiseAndAssign, BinaryOperator_Details::BitwiseOrAssign, BinaryOperator_Details::BitwiseXorAssign, BinaryOperator_Details::BitwiseLeftShiftAssign, BinaryOperator_Details::BitwiseRightShiftAssign, BinaryOperator_Details::AddAssign, BinaryOperator_Details::SubtractAssign, BinaryOperator_Details::MultiplyAssign, BinaryOperator_Details::ModuloAssign, BinaryOperator_Details::DivideAssign, BinaryOperator_Details::NoneCoalescingAssign, BinaryOperator_Details::Garbage>::Variant;
+    using Add = BinaryOperator_Details::Add;
+    using Subtract = BinaryOperator_Details::Subtract;
+    using Multiply = BinaryOperator_Details::Multiply;
+    using Divide = BinaryOperator_Details::Divide;
+    using Modulo = BinaryOperator_Details::Modulo;
+    using LessThan = BinaryOperator_Details::LessThan;
+    using LessThanOrEqual = BinaryOperator_Details::LessThanOrEqual;
+    using GreaterThan = BinaryOperator_Details::GreaterThan;
+    using GreaterThanOrEqual = BinaryOperator_Details::GreaterThanOrEqual;
+    using Equal = BinaryOperator_Details::Equal;
+    using NotEqual = BinaryOperator_Details::NotEqual;
+    using BitwiseAnd = BinaryOperator_Details::BitwiseAnd;
+    using BitwiseXor = BinaryOperator_Details::BitwiseXor;
+    using BitwiseOr = BinaryOperator_Details::BitwiseOr;
+    using BitwiseLeftShift = BinaryOperator_Details::BitwiseLeftShift;
+    using BitwiseRightShift = BinaryOperator_Details::BitwiseRightShift;
+    using ArithmeticLeftShift = BinaryOperator_Details::ArithmeticLeftShift;
+    using ArithmeticRightShift = BinaryOperator_Details::ArithmeticRightShift;
+    using LogicalAnd = BinaryOperator_Details::LogicalAnd;
+    using LogicalOr = BinaryOperator_Details::LogicalOr;
+    using NoneCoalescing = BinaryOperator_Details::NoneCoalescing;
+    using Assign = BinaryOperator_Details::Assign;
+    using BitwiseAndAssign = BinaryOperator_Details::BitwiseAndAssign;
+    using BitwiseOrAssign = BinaryOperator_Details::BitwiseOrAssign;
+    using BitwiseXorAssign = BinaryOperator_Details::BitwiseXorAssign;
+    using BitwiseLeftShiftAssign = BinaryOperator_Details::BitwiseLeftShiftAssign;
+    using BitwiseRightShiftAssign = BinaryOperator_Details::BitwiseRightShiftAssign;
+    using AddAssign = BinaryOperator_Details::AddAssign;
+    using SubtractAssign = BinaryOperator_Details::SubtractAssign;
+    using MultiplyAssign = BinaryOperator_Details::MultiplyAssign;
+    using ModuloAssign = BinaryOperator_Details::ModuloAssign;
+    using DivideAssign = BinaryOperator_Details::DivideAssign;
+    using NoneCoalescingAssign = BinaryOperator_Details::NoneCoalescingAssign;
+    using Garbage = BinaryOperator_Details::Garbage;
+ErrorOr<DeprecatedString> debug_description() const;
+bool equals(parser::BinaryOperator const rhs_op) const;
+bool is_assignment() const;
+};
+struct ParsedAttribute {
+  public:
+DeprecatedString name;utility::Span span;JaktInternal::Optional<DeprecatedString> assigned_value;JaktInternal::DynamicArray<parser::ParsedAttributeArgument> arguments;ParsedAttribute(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<DeprecatedString> a_assigned_value, JaktInternal::DynamicArray<parser::ParsedAttributeArgument> a_arguments);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace DefinitionLinkage_Details {
+struct Internal {
+};
+struct External {
+};
+}
+struct DefinitionLinkage : public Variant<DefinitionLinkage_Details::Internal, DefinitionLinkage_Details::External> {
+using Variant<DefinitionLinkage_Details::Internal, DefinitionLinkage_Details::External>::Variant;
+    using Internal = DefinitionLinkage_Details::Internal;
+    using External = DefinitionLinkage_Details::External;
+ErrorOr<DeprecatedString> debug_description() const;
+};
+namespace RecordType_Details {
+struct Struct {
+JaktInternal::DynamicArray<parser::ParsedField> fields;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> super_type;
+template<typename _MemberT0, typename _MemberT1>
+Struct(_MemberT0&& member_0, _MemberT1&& member_1):
+fields{ forward<_MemberT0>(member_0)},
+super_type{ forward<_MemberT1>(member_1)}
 {}
 };
-struct F32{
-f32 value;
-template<typename _MemberT0>
-F32(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct Class {
+JaktInternal::DynamicArray<parser::ParsedField> fields;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> super_type;
+template<typename _MemberT0, typename _MemberT1>
+Class(_MemberT0&& member_0, _MemberT1&& member_1):
+fields{ forward<_MemberT0>(member_0)},
+super_type{ forward<_MemberT1>(member_1)}
 {}
 };
-struct F64{
-f64 value;
-template<typename _MemberT0>
-F64(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct ValueEnum {
+NonnullRefPtr<typename parser::ParsedType> underlying_type;
+JaktInternal::DynamicArray<parser::ValueEnumVariant> variants;
+template<typename _MemberT0, typename _MemberT1>
+ValueEnum(_MemberT0&& member_0, _MemberT1&& member_1):
+underlying_type{ forward<_MemberT0>(member_0)},
+variants{ forward<_MemberT1>(member_1)}
 {}
 };
-struct UnknownSigned{
-i64 value;
-template<typename _MemberT0>
-UnknownSigned(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct SumEnum {
+bool is_boxed;
+JaktInternal::DynamicArray<parser::ParsedField> fields;
+JaktInternal::DynamicArray<parser::SumEnumVariant> variants;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+SumEnum(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+is_boxed{ forward<_MemberT0>(member_0)},
+fields{ forward<_MemberT1>(member_1)},
+variants{ forward<_MemberT2>(member_2)}
 {}
 };
-struct UnknownUnsigned{
-u64 value;
+struct Garbage {
+};
+}
+struct RecordType : public Variant<RecordType_Details::Struct, RecordType_Details::Class, RecordType_Details::ValueEnum, RecordType_Details::SumEnum, RecordType_Details::Garbage> {
+using Variant<RecordType_Details::Struct, RecordType_Details::Class, RecordType_Details::ValueEnum, RecordType_Details::SumEnum, RecordType_Details::Garbage>::Variant;
+    using Struct = RecordType_Details::Struct;
+    using Class = RecordType_Details::Class;
+    using ValueEnum = RecordType_Details::ValueEnum;
+    using SumEnum = RecordType_Details::SumEnum;
+    using Garbage = RecordType_Details::Garbage;
+ErrorOr<DeprecatedString> debug_description() const;
+DeprecatedString record_type_name() const;
+};
+struct ParsedRecord {
+  public:
+DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<parser::ParsedGenericParameter> generic_parameters;parser::DefinitionLinkage definition_linkage;JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> implements_list;JaktInternal::DynamicArray<parser::ParsedMethod> methods;parser::RecordType record_type;JaktInternal::Optional<DeprecatedString> external_name;ParsedRecord(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<parser::ParsedGenericParameter> a_generic_parameters, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> a_implements_list, JaktInternal::DynamicArray<parser::ParsedMethod> a_methods, parser::RecordType a_record_type, JaktInternal::Optional<DeprecatedString> a_external_name);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};struct ParsedAttributeArgument {
+  public:
+DeprecatedString name;utility::Span span;JaktInternal::Optional<DeprecatedString> assigned_value;ParsedAttributeArgument(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<DeprecatedString> a_assigned_value);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace ArgumentStoreLevel_Details {
+struct InObject {
+size_t argument_index;
 template<typename _MemberT0>
-UnknownUnsigned(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+InObject(_MemberT0&& member_0):
+argument_index{ forward<_MemberT0>(member_0)}
 {}
 };
+struct InStaticStorage {
+};
 }
-struct NumericConstant : public Variant<NumericConstant_Details::I8, NumericConstant_Details::I16, NumericConstant_Details::I32, NumericConstant_Details::I64, NumericConstant_Details::U8, NumericConstant_Details::U16, NumericConstant_Details::U32, NumericConstant_Details::U64, NumericConstant_Details::USize, NumericConstant_Details::F32, NumericConstant_Details::F64, NumericConstant_Details::UnknownSigned, NumericConstant_Details::UnknownUnsigned> {
-using Variant<NumericConstant_Details::I8, NumericConstant_Details::I16, NumericConstant_Details::I32, NumericConstant_Details::I64, NumericConstant_Details::U8, NumericConstant_Details::U16, NumericConstant_Details::U32, NumericConstant_Details::U64, NumericConstant_Details::USize, NumericConstant_Details::F32, NumericConstant_Details::F64, NumericConstant_Details::UnknownSigned, NumericConstant_Details::UnknownUnsigned>::Variant;
-    using I8 = NumericConstant_Details::I8;
-    using I16 = NumericConstant_Details::I16;
-    using I32 = NumericConstant_Details::I32;
-    using I64 = NumericConstant_Details::I64;
-    using U8 = NumericConstant_Details::U8;
-    using U16 = NumericConstant_Details::U16;
-    using U32 = NumericConstant_Details::U32;
-    using U64 = NumericConstant_Details::U64;
-    using USize = NumericConstant_Details::USize;
-    using F32 = NumericConstant_Details::F32;
-    using F64 = NumericConstant_Details::F64;
-    using UnknownSigned = NumericConstant_Details::UnknownSigned;
-    using UnknownUnsigned = NumericConstant_Details::UnknownUnsigned;
+struct ArgumentStoreLevel : public Variant<ArgumentStoreLevel_Details::InObject, ArgumentStoreLevel_Details::InStaticStorage> {
+using Variant<ArgumentStoreLevel_Details::InObject, ArgumentStoreLevel_Details::InStaticStorage>::Variant;
+    using InObject = ArgumentStoreLevel_Details::InObject;
+    using InStaticStorage = ArgumentStoreLevel_Details::InStaticStorage;
 ErrorOr<DeprecatedString> debug_description() const;
-size_t to_usize() const;
 };
-struct ParsedCall {
+struct ParsedNameWithGenericParameters {
   public:
-JaktInternal::DynamicArray<DeprecatedString> namespace_;DeprecatedString name;JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> args;JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> type_args;ParsedCall(JaktInternal::DynamicArray<DeprecatedString> a_namespace_, DeprecatedString a_name, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> a_args, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> a_type_args);
+DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> generic_parameters;ParsedNameWithGenericParameters(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> a_generic_parameters);
 
-bool equals(parser::ParsedCall const rhs_parsed_call) const;
 ErrorOr<DeprecatedString> debug_description() const;
 };namespace TypeCast_Details {
 struct Fallible{
@@ -191,163 +349,173 @@ using Variant<TypeCast_Details::Fallible, TypeCast_Details::Infallible>::Variant
 ErrorOr<DeprecatedString> debug_description() const;
 NonnullRefPtr<typename parser::ParsedType> parsed_type() const;
 };
-namespace ParsedType_Details {
-struct Name {
+struct ParsedVarDecl {
+  public:
+DeprecatedString name;NonnullRefPtr<typename parser::ParsedType> parsed_type;bool is_mutable;JaktInternal::Optional<utility::Span> inlay_span;utility::Span span;bool equals(parser::ParsedVarDecl const rhs_var_decl) const;
+ParsedVarDecl(DeprecatedString a_name, NonnullRefPtr<typename parser::ParsedType> a_parsed_type, bool a_is_mutable, JaktInternal::Optional<utility::Span> a_inlay_span, utility::Span a_span);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace ImportName_Details {
+struct Literal {
 DeprecatedString name;
 utility::Span span;
 template<typename _MemberT0, typename _MemberT1>
-Name(_MemberT0&& member_0, _MemberT1&& member_1):
+Literal(_MemberT0&& member_0, _MemberT1&& member_1):
 name{ forward<_MemberT0>(member_0)},
 span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct NamespacedName {
-DeprecatedString name;
-JaktInternal::DynamicArray<DeprecatedString> namespaces;
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> params;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-NamespacedName(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-name{ forward<_MemberT0>(member_0)},
-namespaces{ forward<_MemberT1>(member_1)},
-params{ forward<_MemberT2>(member_2)},
-span{ forward<_MemberT3>(member_3)}
+struct Comptime {
+NonnullRefPtr<typename parser::ParsedExpression> expression;
+template<typename _MemberT0>
+Comptime(_MemberT0&& member_0):
+expression{ forward<_MemberT0>(member_0)}
 {}
 };
-struct GenericType {
-DeprecatedString name;
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> generic_parameters;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-GenericType(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
-name{ forward<_MemberT0>(member_0)},
-generic_parameters{ forward<_MemberT1>(member_1)},
-span{ forward<_MemberT2>(member_2)}
+}
+struct ImportName : public Variant<ImportName_Details::Literal, ImportName_Details::Comptime> {
+using Variant<ImportName_Details::Literal, ImportName_Details::Comptime>::Variant;
+    using Literal = ImportName_Details::Literal;
+    using Comptime = ImportName_Details::Comptime;
+ErrorOr<DeprecatedString> debug_description() const;
+DeprecatedString literal_name() const;
+bool equals(parser::ImportName const other) const;
+utility::Span span() const;
+};
+struct ParsedName {
+  public:
+DeprecatedString name;utility::Span span;ParsedName(DeprecatedString a_name, utility::Span a_span);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};struct ParsedVariable {
+  public:
+DeprecatedString name;NonnullRefPtr<typename parser::ParsedType> parsed_type;bool is_mutable;utility::Span span;ParsedVariable(DeprecatedString a_name, NonnullRefPtr<typename parser::ParsedType> a_parsed_type, bool a_is_mutable, utility::Span a_span);
+
+bool equals(parser::ParsedVariable const rhs_parsed_varible) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace NumericConstant_Details {
+struct I8{
+i8 value;
+template<typename _MemberT0>
+I8(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct JaktArray {
-NonnullRefPtr<typename parser::ParsedType> inner;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-JaktArray(_MemberT0&& member_0, _MemberT1&& member_1):
-inner{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+struct I16{
+i16 value;
+template<typename _MemberT0>
+I16(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Dictionary {
-NonnullRefPtr<typename parser::ParsedType> key;
-NonnullRefPtr<typename parser::ParsedType> value;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-Dictionary(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
-key{ forward<_MemberT0>(member_0)},
-value{ forward<_MemberT1>(member_1)},
-span{ forward<_MemberT2>(member_2)}
+struct I32{
+i32 value;
+template<typename _MemberT0>
+I32(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct JaktTuple {
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> types;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-JaktTuple(_MemberT0&& member_0, _MemberT1&& member_1):
-types{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+struct I64{
+i64 value;
+template<typename _MemberT0>
+I64(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Set {
-NonnullRefPtr<typename parser::ParsedType> inner;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Set(_MemberT0&& member_0, _MemberT1&& member_1):
-inner{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+struct U8{
+u8 value;
+template<typename _MemberT0>
+U8(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Optional {
-NonnullRefPtr<typename parser::ParsedType> inner;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Optional(_MemberT0&& member_0, _MemberT1&& member_1):
-inner{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+struct U16{
+u16 value;
+template<typename _MemberT0>
+U16(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Reference {
-NonnullRefPtr<typename parser::ParsedType> inner;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Reference(_MemberT0&& member_0, _MemberT1&& member_1):
-inner{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+struct U32{
+u32 value;
+template<typename _MemberT0>
+U32(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct MutableReference {
-NonnullRefPtr<typename parser::ParsedType> inner;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-MutableReference(_MemberT0&& member_0, _MemberT1&& member_1):
-inner{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+struct U64{
+u64 value;
+template<typename _MemberT0>
+U64(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct RawPtr {
-NonnullRefPtr<typename parser::ParsedType> inner;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-RawPtr(_MemberT0&& member_0, _MemberT1&& member_1):
-inner{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+struct USize{
+u64 value;
+template<typename _MemberT0>
+USize(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct F32{
+f32 value;
+template<typename _MemberT0>
+F32(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct WeakPtr {
-NonnullRefPtr<typename parser::ParsedType> inner;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-WeakPtr(_MemberT0&& member_0, _MemberT1&& member_1):
-inner{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+struct F64{
+f64 value;
+template<typename _MemberT0>
+F64(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Function {
-JaktInternal::DynamicArray<parser::ParsedParameter> params;
-bool can_throw;
-NonnullRefPtr<typename parser::ParsedType> return_type;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-Function(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-params{ forward<_MemberT0>(member_0)},
-can_throw{ forward<_MemberT1>(member_1)},
-return_type{ forward<_MemberT2>(member_2)},
-span{ forward<_MemberT3>(member_3)}
+struct UnknownSigned{
+i64 value;
+template<typename _MemberT0>
+UnknownSigned(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Empty {
+struct UnknownUnsigned{
+u64 value;
+template<typename _MemberT0>
+UnknownUnsigned(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
 };
 }
-struct ParsedType : public Variant<ParsedType_Details::Name, ParsedType_Details::NamespacedName, ParsedType_Details::GenericType, ParsedType_Details::JaktArray, ParsedType_Details::Dictionary, ParsedType_Details::JaktTuple, ParsedType_Details::Set, ParsedType_Details::Optional, ParsedType_Details::Reference, ParsedType_Details::MutableReference, ParsedType_Details::RawPtr, ParsedType_Details::WeakPtr, ParsedType_Details::Function, ParsedType_Details::Empty>, public RefCounted<ParsedType> {
-using Variant<ParsedType_Details::Name, ParsedType_Details::NamespacedName, ParsedType_Details::GenericType, ParsedType_Details::JaktArray, ParsedType_Details::Dictionary, ParsedType_Details::JaktTuple, ParsedType_Details::Set, ParsedType_Details::Optional, ParsedType_Details::Reference, ParsedType_Details::MutableReference, ParsedType_Details::RawPtr, ParsedType_Details::WeakPtr, ParsedType_Details::Function, ParsedType_Details::Empty>::Variant;
-    using Name = ParsedType_Details::Name;
-    using NamespacedName = ParsedType_Details::NamespacedName;
-    using GenericType = ParsedType_Details::GenericType;
-    using JaktArray = ParsedType_Details::JaktArray;
-    using Dictionary = ParsedType_Details::Dictionary;
-    using JaktTuple = ParsedType_Details::JaktTuple;
-    using Set = ParsedType_Details::Set;
-    using Optional = ParsedType_Details::Optional;
-    using Reference = ParsedType_Details::Reference;
-    using MutableReference = ParsedType_Details::MutableReference;
-    using RawPtr = ParsedType_Details::RawPtr;
-    using WeakPtr = ParsedType_Details::WeakPtr;
-    using Function = ParsedType_Details::Function;
-    using Empty = ParsedType_Details::Empty;
-template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
-return adopt_nonnull_ref_or_enomem(new (nothrow) ParsedType(V(forward<Args>(args)...)));
-}
+struct NumericConstant : public Variant<NumericConstant_Details::I8, NumericConstant_Details::I16, NumericConstant_Details::I32, NumericConstant_Details::I64, NumericConstant_Details::U8, NumericConstant_Details::U16, NumericConstant_Details::U32, NumericConstant_Details::U64, NumericConstant_Details::USize, NumericConstant_Details::F32, NumericConstant_Details::F64, NumericConstant_Details::UnknownSigned, NumericConstant_Details::UnknownUnsigned> {
+using Variant<NumericConstant_Details::I8, NumericConstant_Details::I16, NumericConstant_Details::I32, NumericConstant_Details::I64, NumericConstant_Details::U8, NumericConstant_Details::U16, NumericConstant_Details::U32, NumericConstant_Details::U64, NumericConstant_Details::USize, NumericConstant_Details::F32, NumericConstant_Details::F64, NumericConstant_Details::UnknownSigned, NumericConstant_Details::UnknownUnsigned>::Variant;
+    using I8 = NumericConstant_Details::I8;
+    using I16 = NumericConstant_Details::I16;
+    using I32 = NumericConstant_Details::I32;
+    using I64 = NumericConstant_Details::I64;
+    using U8 = NumericConstant_Details::U8;
+    using U16 = NumericConstant_Details::U16;
+    using U32 = NumericConstant_Details::U32;
+    using U64 = NumericConstant_Details::U64;
+    using USize = NumericConstant_Details::USize;
+    using F32 = NumericConstant_Details::F32;
+    using F64 = NumericConstant_Details::F64;
+    using UnknownSigned = NumericConstant_Details::UnknownSigned;
+    using UnknownUnsigned = NumericConstant_Details::UnknownUnsigned;
 ErrorOr<DeprecatedString> debug_description() const;
-bool equals(NonnullRefPtr<typename parser::ParsedType> const rhs_parsed_type) const;
-utility::Span span() const;
+size_t to_usize() const;
 };
-namespace UnaryOperator_Details {
+struct ParsedVarDeclTuple {
+  public:
+JaktInternal::DynamicArray<parser::ParsedVarDecl> var_decls;utility::Span span;ParsedVarDeclTuple(JaktInternal::DynamicArray<parser::ParsedVarDecl> a_var_decls, utility::Span a_span);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};struct ParsedCall {
+  public:
+JaktInternal::DynamicArray<DeprecatedString> namespace_;DeprecatedString name;JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> args;JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> type_args;ParsedCall(JaktInternal::DynamicArray<DeprecatedString> a_namespace_, DeprecatedString a_name, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> a_args, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> a_type_args);
+
+bool equals(parser::ParsedCall const rhs_parsed_call) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace UnaryOperator_Details {
 struct PreIncrement {
 };
 struct PostIncrement {
@@ -421,116 +589,6 @@ using Variant<UnaryOperator_Details::PreIncrement, UnaryOperator_Details::PostIn
 ErrorOr<DeprecatedString> debug_description() const;
 bool equals(parser::UnaryOperator const rhs_op) const;
 };
-namespace BinaryOperator_Details {
-struct Add {
-};
-struct Subtract {
-};
-struct Multiply {
-};
-struct Divide {
-};
-struct Modulo {
-};
-struct LessThan {
-};
-struct LessThanOrEqual {
-};
-struct GreaterThan {
-};
-struct GreaterThanOrEqual {
-};
-struct Equal {
-};
-struct NotEqual {
-};
-struct BitwiseAnd {
-};
-struct BitwiseXor {
-};
-struct BitwiseOr {
-};
-struct BitwiseLeftShift {
-};
-struct BitwiseRightShift {
-};
-struct ArithmeticLeftShift {
-};
-struct ArithmeticRightShift {
-};
-struct LogicalAnd {
-};
-struct LogicalOr {
-};
-struct NoneCoalescing {
-};
-struct Assign {
-};
-struct BitwiseAndAssign {
-};
-struct BitwiseOrAssign {
-};
-struct BitwiseXorAssign {
-};
-struct BitwiseLeftShiftAssign {
-};
-struct BitwiseRightShiftAssign {
-};
-struct AddAssign {
-};
-struct SubtractAssign {
-};
-struct MultiplyAssign {
-};
-struct ModuloAssign {
-};
-struct DivideAssign {
-};
-struct NoneCoalescingAssign {
-};
-struct Garbage {
-};
-}
-struct BinaryOperator : public Variant<BinaryOperator_Details::Add, BinaryOperator_Details::Subtract, BinaryOperator_Details::Multiply, BinaryOperator_Details::Divide, BinaryOperator_Details::Modulo, BinaryOperator_Details::LessThan, BinaryOperator_Details::LessThanOrEqual, BinaryOperator_Details::GreaterThan, BinaryOperator_Details::GreaterThanOrEqual, BinaryOperator_Details::Equal, BinaryOperator_Details::NotEqual, BinaryOperator_Details::BitwiseAnd, BinaryOperator_Details::BitwiseXor, BinaryOperator_Details::BitwiseOr, BinaryOperator_Details::BitwiseLeftShift, BinaryOperator_Details::BitwiseRightShift, BinaryOperator_Details::ArithmeticLeftShift, BinaryOperator_Details::ArithmeticRightShift, BinaryOperator_Details::LogicalAnd, BinaryOperator_Details::LogicalOr, BinaryOperator_Details::NoneCoalescing, BinaryOperator_Details::Assign, BinaryOperator_Details::BitwiseAndAssign, BinaryOperator_Details::BitwiseOrAssign, BinaryOperator_Details::BitwiseXorAssign, BinaryOperator_Details::BitwiseLeftShiftAssign, BinaryOperator_Details::BitwiseRightShiftAssign, BinaryOperator_Details::AddAssign, BinaryOperator_Details::SubtractAssign, BinaryOperator_Details::MultiplyAssign, BinaryOperator_Details::ModuloAssign, BinaryOperator_Details::DivideAssign, BinaryOperator_Details::NoneCoalescingAssign, BinaryOperator_Details::Garbage> {
-using Variant<BinaryOperator_Details::Add, BinaryOperator_Details::Subtract, BinaryOperator_Details::Multiply, BinaryOperator_Details::Divide, BinaryOperator_Details::Modulo, BinaryOperator_Details::LessThan, BinaryOperator_Details::LessThanOrEqual, BinaryOperator_Details::GreaterThan, BinaryOperator_Details::GreaterThanOrEqual, BinaryOperator_Details::Equal, BinaryOperator_Details::NotEqual, BinaryOperator_Details::BitwiseAnd, BinaryOperator_Details::BitwiseXor, BinaryOperator_Details::BitwiseOr, BinaryOperator_Details::BitwiseLeftShift, BinaryOperator_Details::BitwiseRightShift, BinaryOperator_Details::ArithmeticLeftShift, BinaryOperator_Details::ArithmeticRightShift, BinaryOperator_Details::LogicalAnd, BinaryOperator_Details::LogicalOr, BinaryOperator_Details::NoneCoalescing, BinaryOperator_Details::Assign, BinaryOperator_Details::BitwiseAndAssign, BinaryOperator_Details::BitwiseOrAssign, BinaryOperator_Details::BitwiseXorAssign, BinaryOperator_Details::BitwiseLeftShiftAssign, BinaryOperator_Details::BitwiseRightShiftAssign, BinaryOperator_Details::AddAssign, BinaryOperator_Details::SubtractAssign, BinaryOperator_Details::MultiplyAssign, BinaryOperator_Details::ModuloAssign, BinaryOperator_Details::DivideAssign, BinaryOperator_Details::NoneCoalescingAssign, BinaryOperator_Details::Garbage>::Variant;
-    using Add = BinaryOperator_Details::Add;
-    using Subtract = BinaryOperator_Details::Subtract;
-    using Multiply = BinaryOperator_Details::Multiply;
-    using Divide = BinaryOperator_Details::Divide;
-    using Modulo = BinaryOperator_Details::Modulo;
-    using LessThan = BinaryOperator_Details::LessThan;
-    using LessThanOrEqual = BinaryOperator_Details::LessThanOrEqual;
-    using GreaterThan = BinaryOperator_Details::GreaterThan;
-    using GreaterThanOrEqual = BinaryOperator_Details::GreaterThanOrEqual;
-    using Equal = BinaryOperator_Details::Equal;
-    using NotEqual = BinaryOperator_Details::NotEqual;
-    using BitwiseAnd = BinaryOperator_Details::BitwiseAnd;
-    using BitwiseXor = BinaryOperator_Details::BitwiseXor;
-    using BitwiseOr = BinaryOperator_Details::BitwiseOr;
-    using BitwiseLeftShift = BinaryOperator_Details::BitwiseLeftShift;
-    using BitwiseRightShift = BinaryOperator_Details::BitwiseRightShift;
-    using ArithmeticLeftShift = BinaryOperator_Details::ArithmeticLeftShift;
-    using ArithmeticRightShift = BinaryOperator_Details::ArithmeticRightShift;
-    using LogicalAnd = BinaryOperator_Details::LogicalAnd;
-    using LogicalOr = BinaryOperator_Details::LogicalOr;
-    using NoneCoalescing = BinaryOperator_Details::NoneCoalescing;
-    using Assign = BinaryOperator_Details::Assign;
-    using BitwiseAndAssign = BinaryOperator_Details::BitwiseAndAssign;
-    using BitwiseOrAssign = BinaryOperator_Details::BitwiseOrAssign;
-    using BitwiseXorAssign = BinaryOperator_Details::BitwiseXorAssign;
-    using BitwiseLeftShiftAssign = BinaryOperator_Details::BitwiseLeftShiftAssign;
-    using BitwiseRightShiftAssign = BinaryOperator_Details::BitwiseRightShiftAssign;
-    using AddAssign = BinaryOperator_Details::AddAssign;
-    using SubtractAssign = BinaryOperator_Details::SubtractAssign;
-    using MultiplyAssign = BinaryOperator_Details::MultiplyAssign;
-    using ModuloAssign = BinaryOperator_Details::ModuloAssign;
-    using DivideAssign = BinaryOperator_Details::DivideAssign;
-    using NoneCoalescingAssign = BinaryOperator_Details::NoneCoalescingAssign;
-    using Garbage = BinaryOperator_Details::Garbage;
-ErrorOr<DeprecatedString> debug_description() const;
-bool equals(parser::BinaryOperator const rhs_op) const;
-bool is_assignment() const;
-};
 struct EnumVariantPatternArgument {
   public:
 JaktInternal::Optional<DeprecatedString> name;DeprecatedString binding;utility::Span span;bool is_reference;bool is_mutable;EnumVariantPatternArgument(JaktInternal::Optional<DeprecatedString> a_name, DeprecatedString a_binding, utility::Span a_span, bool a_is_reference, bool a_is_mutable);
@@ -905,38 +963,100 @@ bool equals(NonnullRefPtr<typename parser::ParsedExpression> const rhs_expressio
 utility::Span span() const;
 i64 precedence() const;
 };
-struct ParsedPatternDefault {
-  public:
-parser::ParsedVarDecl variable;NonnullRefPtr<typename parser::ParsedExpression> value;ParsedPatternDefault(parser::ParsedVarDecl a_variable, NonnullRefPtr<typename parser::ParsedExpression> a_value);
-
+namespace IncludeAction_Details {
+struct Define {
+DeprecatedString name;
+utility::Span span;
+DeprecatedString value;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+Define(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)},
+value{ forward<_MemberT2>(member_2)}
+{}
+};
+struct Undefine {
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Undefine(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+}
+struct IncludeAction : public Variant<IncludeAction_Details::Define, IncludeAction_Details::Undefine> {
+using Variant<IncludeAction_Details::Define, IncludeAction_Details::Undefine>::Variant;
+    using Define = IncludeAction_Details::Define;
+    using Undefine = IncludeAction_Details::Undefine;
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedExternalTraitImplementation {
-  public:
-NonnullRefPtr<typename parser::ParsedType> for_type;JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> traits;JaktInternal::DynamicArray<parser::ParsedMethod> methods;ParsedExternalTraitImplementation(NonnullRefPtr<typename parser::ParsedType> a_for_type, JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> a_traits, JaktInternal::DynamicArray<parser::ParsedMethod> a_methods);
-
+};
+namespace ImportList_Details {
+struct List{
+JaktInternal::DynamicArray<parser::ImportName> value;
+template<typename _MemberT0>
+List(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct All {
+};
+}
+struct ImportList : public Variant<ImportList_Details::List, ImportList_Details::All> {
+using Variant<ImportList_Details::List, ImportList_Details::All>::Variant;
+    using List = ImportList_Details::List;
+    using All = ImportList_Details::All;
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedVariable {
+ErrorOr<void> add(parser::ImportName const name);
+bool is_empty() const;
+};
+struct ParsedModuleImport {
   public:
-DeprecatedString name;NonnullRefPtr<typename parser::ParsedType> parsed_type;bool is_mutable;utility::Span span;bool equals(parser::ParsedVariable const rhs_parsed_varible) const;
-ParsedVariable(DeprecatedString a_name, NonnullRefPtr<typename parser::ParsedType> a_parsed_type, bool a_is_mutable, utility::Span a_span);
+parser::ImportName module_name;JaktInternal::Optional<parser::ImportName> alias_name;parser::ImportList import_list;bool has_same_alias_than(parser::ParsedModuleImport const other) const;
+ParsedModuleImport(parser::ImportName a_module_name, JaktInternal::Optional<parser::ImportName> a_alias_name, parser::ImportList a_import_list);
 
+bool has_same_import_semantics(parser::ParsedModuleImport const other) const;
+ErrorOr<void> merge_import_list(parser::ImportList const list);
+bool is_equivalent_to(parser::ParsedModuleImport const other) const;
 ErrorOr<DeprecatedString> debug_description() const;
 };struct ParsedGenericParameter {
   public:
 DeprecatedString name;utility::Span span;JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> requires_list;ParsedGenericParameter(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> a_requires_list);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedName {
+};struct ParsedPatternDefault {
   public:
-DeprecatedString name;utility::Span span;ParsedName(DeprecatedString a_name, utility::Span a_span);
+parser::ParsedVarDecl variable;NonnullRefPtr<typename parser::ParsedExpression> value;ParsedPatternDefault(parser::ParsedVarDecl a_variable, NonnullRefPtr<typename parser::ParsedExpression> a_value);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedAlias {
+};struct ParsedExternalTraitImplementation {
   public:
-JaktInternal::Optional<parser::ParsedName> alias_name;JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> target;ParsedAlias(JaktInternal::Optional<parser::ParsedName> a_alias_name, JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> a_target);
+NonnullRefPtr<typename parser::ParsedType> for_type;JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> traits;JaktInternal::DynamicArray<parser::ParsedMethod> methods;ParsedExternalTraitImplementation(NonnullRefPtr<typename parser::ParsedType> a_for_type, JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> a_traits, JaktInternal::DynamicArray<parser::ParsedMethod> a_methods);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace FunctionType_Details {
+};namespace Visibility_Details {
+struct Public {
+};
+struct Private {
+};
+struct Restricted {
+JaktInternal::DynamicArray<parser::VisibilityRestriction> whitelist;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Restricted(_MemberT0&& member_0, _MemberT1&& member_1):
+whitelist{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+}
+struct Visibility : public Variant<Visibility_Details::Public, Visibility_Details::Private, Visibility_Details::Restricted> {
+using Variant<Visibility_Details::Public, Visibility_Details::Private, Visibility_Details::Restricted>::Variant;
+    using Public = Visibility_Details::Public;
+    using Private = Visibility_Details::Private;
+    using Restricted = Visibility_Details::Restricted;
+ErrorOr<DeprecatedString> debug_description() const;
+};
+namespace FunctionType_Details {
 struct Normal {
 };
 struct Destructor {
@@ -963,28 +1083,6 @@ using Variant<FunctionType_Details::Normal, FunctionType_Details::Destructor, Fu
     using Closure = FunctionType_Details::Closure;
 ErrorOr<DeprecatedString> debug_description() const;
 };
-namespace Visibility_Details {
-struct Public {
-};
-struct Private {
-};
-struct Restricted {
-JaktInternal::DynamicArray<parser::VisibilityRestriction> whitelist;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Restricted(_MemberT0&& member_0, _MemberT1&& member_1):
-whitelist{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-}
-struct Visibility : public Variant<Visibility_Details::Public, Visibility_Details::Private, Visibility_Details::Restricted> {
-using Variant<Visibility_Details::Public, Visibility_Details::Private, Visibility_Details::Restricted>::Variant;
-    using Public = Visibility_Details::Public;
-    using Private = Visibility_Details::Private;
-    using Restricted = Visibility_Details::Restricted;
-ErrorOr<DeprecatedString> debug_description() const;
-};
 namespace FunctionLinkage_Details {
 struct Internal {
 };
@@ -1003,373 +1101,368 @@ DeprecatedString name;utility::Span name_span;parser::Visibility visibility;Jakt
 
 bool equals(parser::ParsedFunction const other) const;
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace ImportName_Details {
-struct Literal {
-DeprecatedString name;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Literal(_MemberT0&& member_0, _MemberT1&& member_1):
-name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Comptime {
-NonnullRefPtr<typename parser::ParsedExpression> expression;
-template<typename _MemberT0>
-Comptime(_MemberT0&& member_0):
-expression{ forward<_MemberT0>(member_0)}
-{}
-};
-}
-struct ImportName : public Variant<ImportName_Details::Literal, ImportName_Details::Comptime> {
-using Variant<ImportName_Details::Literal, ImportName_Details::Comptime>::Variant;
-    using Literal = ImportName_Details::Literal;
-    using Comptime = ImportName_Details::Comptime;
-ErrorOr<DeprecatedString> debug_description() const;
-DeprecatedString literal_name() const;
-bool equals(parser::ImportName const other) const;
-utility::Span span() const;
-};
-struct ParsedVarDeclTuple {
-  public:
-JaktInternal::DynamicArray<parser::ParsedVarDecl> var_decls;utility::Span span;ParsedVarDeclTuple(JaktInternal::DynamicArray<parser::ParsedVarDecl> a_var_decls, utility::Span a_span);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct ValueEnumVariant {
+};struct ParsedMethod {
   public:
-DeprecatedString name;utility::Span span;JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> value;ValueEnumVariant(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_value);
+parser::ParsedFunction parsed_function;parser::Visibility visibility;bool is_virtual;bool is_override;ParsedMethod(parser::ParsedFunction a_parsed_function, parser::Visibility a_visibility, bool a_is_virtual, bool a_is_override);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedNamespace {
+};struct ParsedParameter {
   public:
-JaktInternal::Optional<DeprecatedString> name;JaktInternal::Optional<utility::Span> name_span;JaktInternal::DynamicArray<parser::ParsedFunction> functions;JaktInternal::DynamicArray<parser::ParsedRecord> records;JaktInternal::DynamicArray<parser::ParsedTrait> traits;JaktInternal::DynamicArray<parser::ParsedExternalTraitImplementation> external_trait_implementations;JaktInternal::DynamicArray<parser::ParsedNamespace> namespaces;JaktInternal::DynamicArray<parser::ParsedAlias> aliases;JaktInternal::DynamicArray<parser::ParsedModuleImport> module_imports;JaktInternal::DynamicArray<parser::ParsedExternImport> extern_imports;JaktInternal::Optional<DeprecatedString> import_path_if_extern;JaktInternal::DynamicArray<parser::IncludeAction> generating_import_extern_before_include;JaktInternal::DynamicArray<parser::IncludeAction> generating_import_extern_after_include;ErrorOr<void> add_child_namespace(parser::ParsedNamespace const namespace_);
-ParsedNamespace(JaktInternal::Optional<DeprecatedString> a_name, JaktInternal::Optional<utility::Span> a_name_span, JaktInternal::DynamicArray<parser::ParsedFunction> a_functions, JaktInternal::DynamicArray<parser::ParsedRecord> a_records, JaktInternal::DynamicArray<parser::ParsedTrait> a_traits, JaktInternal::DynamicArray<parser::ParsedExternalTraitImplementation> a_external_trait_implementations, JaktInternal::DynamicArray<parser::ParsedNamespace> a_namespaces, JaktInternal::DynamicArray<parser::ParsedAlias> a_aliases, JaktInternal::DynamicArray<parser::ParsedModuleImport> a_module_imports, JaktInternal::DynamicArray<parser::ParsedExternImport> a_extern_imports, JaktInternal::Optional<DeprecatedString> a_import_path_if_extern, JaktInternal::DynamicArray<parser::IncludeAction> a_generating_import_extern_before_include, JaktInternal::DynamicArray<parser::IncludeAction> a_generating_import_extern_after_include);
+bool requires_label;parser::ParsedVariable variable;JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_argument;utility::Span span;ParsedParameter(bool a_requires_label, parser::ParsedVariable a_variable, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_argument, utility::Span a_span);
 
-bool is_equivalent_to(parser::ParsedNamespace const other) const;
-ErrorOr<void> add_extern_import(parser::ParsedExternImport const import_);
-ErrorOr<void> add_alias(parser::ParsedAlias const alias);
-ErrorOr<void> merge_with(parser::ParsedNamespace const namespace_);
-ErrorOr<void> add_module_import(parser::ParsedModuleImport const import_);
+bool equals(parser::ParsedParameter const rhs_param) const;
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedExternImport {
+};struct Parser {
   public:
-bool is_c;parser::ParsedNamespace assigned_namespace;JaktInternal::DynamicArray<parser::IncludeAction> before_include;JaktInternal::DynamicArray<parser::IncludeAction> after_include;ErrorOr<bool> is_equivalent_to(parser::ParsedExternImport const other) const;
-ParsedExternImport(bool a_is_c, parser::ParsedNamespace a_assigned_namespace, JaktInternal::DynamicArray<parser::IncludeAction> a_before_include, JaktInternal::DynamicArray<parser::IncludeAction> a_after_include);
+size_t index;JaktInternal::DynamicArray<lexer::Token> tokens;NonnullRefPtr<compiler::Compiler> compiler;bool can_have_trailing_closure;ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_operand_base();
+utility::Span span(size_t const start, size_t const end) const;
+ErrorOr<JaktInternal::Optional<parser::NumericConstant>> make_integer_numeric_constant(u64 const number, lexer::LiteralSuffix const suffix, utility::Span const span);
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_shorthand();
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_lambda();
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_longhand();
+ErrorOr<parser::ParsedAlias> parse_using();
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedParameter>> parse_function_parameters();
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchCase>> parse_match_cases();
+ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>> parse_attribute();
+ErrorOr<parser::ParsedMethod> parse_method(parser::FunctionLinkage const linkage, parser::Visibility const visibility, bool const is_virtual, bool const is_override, bool const is_comptime, bool const is_destructor);
+ErrorOr<parser::ParsedNamespace> parse_namespace();
+ErrorOr<parser::ParsedVarDecl> parse_variable_declaration(bool const is_mutable);
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_shorthand_set();
+ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parse_if_statement();
+ErrorOr<JaktInternal::Optional<parser::ParsedCall>> parse_call();
+ErrorOr<void> inject_token(lexer::Token const token);
+ErrorOr<parser::ParsedRecord> parse_class(parser::DefinitionLinkage const definition_linkage);
+ErrorOr<parser::ParsedExternalTraitImplementation> parse_external_trait_implementation();
+ErrorOr<parser::ParsedMatchPattern> parse_match_pattern();
+ErrorOr<parser::ParsedFunction> parse_function(parser::FunctionLinkage const linkage, parser::Visibility const visibility, bool const is_comptime, bool const is_destructor, bool const allow_missing_body);
+ErrorOr<parser::ParsedExternImport> parse_extern_import(parser::ParsedNamespace& parent);
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_typename();
+ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parse_struct_class_body(parser::DefinitionLinkage const definition_linkage, parser::Visibility const default_visibility, bool const is_class);
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_range();
+static ErrorOr<parser::ParsedNamespace> parse(NonnullRefPtr<compiler::Compiler> const compiler, JaktInternal::DynamicArray<lexer::Token> const tokens);
+ErrorOr<JaktInternal::Optional<parser::NumericConstant>> make_float_numeric_constant(f64 const number, lexer::LiteralSuffix const suffix, utility::Span const span);
+ErrorOr<parser::ParsedBlock> parse_fat_arrow();
+void skip_newlines();
+lexer::Token previous() const;
+ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parse_value_enum_body(parser::ParsedRecord const partial_enum, parser::DefinitionLinkage const definition_linkage);
+ErrorOr<JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>>> parse_type_parameter_list();
+ErrorOr<JaktInternal::DynamicArray<parser::EnumVariantPatternArgument>> parse_variant_arguments();
+ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parse_guard_statement();
+bool eof() const;
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_asterisk();
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_match_expression();
+ErrorOr<void> apply_attributes(parser::ParsedFunction& parsed_function, JaktInternal::DynamicArray<parser::ParsedAttribute> const& active_attributes);
+ErrorOr<void> apply_attributes(parser::ParsedMethod& parsed_method, JaktInternal::DynamicArray<parser::ParsedAttribute> const& active_attributes);
+ErrorOr<void> apply_attributes(parser::ParsedRecord& parsed_record, JaktInternal::DynamicArray<parser::ParsedAttribute> const& active_attributes);
+lexer::Token current() const;
+ErrorOr<parser::ParsedRecord> parse_enum(parser::DefinitionLinkage const definition_linkage, bool const is_boxed);
+ErrorOr<parser::ParsedBlock> parse_block();
+utility::Span empty_span() const;
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_postfix_colon_colon(utility::Span const start, NonnullRefPtr<typename parser::ParsedExpression> const expr);
+ErrorOr<void> error(DeprecatedString const message, utility::Span const span);
+ErrorOr<parser::ParsedTrait> parse_trait();
+ErrorOr<parser::Visibility> parse_restricted_visibility_modifier();
+ErrorOr<parser::ParsedVarDeclTuple> parse_destructuring_assignment(bool const is_mutable);
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_operand_postfix_operator(utility::Span const start, NonnullRefPtr<typename parser::ParsedExpression> const expr);
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_set_literal();
+ErrorOr<void> parse_attribute_list(JaktInternal::DynamicArray<parser::ParsedAttribute>& active_attributes);
+Parser(size_t a_index, JaktInternal::DynamicArray<lexer::Token> a_tokens, NonnullRefPtr<compiler::Compiler> a_compiler, bool a_can_have_trailing_closure);
 
-DeprecatedString get_name() const;
-DeprecatedString get_path() const;
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace DefinitionLinkage_Details {
-struct Internal {
-};
-struct External {
-};
-}
-struct DefinitionLinkage : public Variant<DefinitionLinkage_Details::Internal, DefinitionLinkage_Details::External> {
-using Variant<DefinitionLinkage_Details::Internal, DefinitionLinkage_Details::External>::Variant;
-    using Internal = DefinitionLinkage_Details::Internal;
-    using External = DefinitionLinkage_Details::External;
-ErrorOr<DeprecatedString> debug_description() const;
-};
-namespace RecordType_Details {
-struct Struct {
-JaktInternal::DynamicArray<parser::ParsedField> fields;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> super_type;
-template<typename _MemberT0, typename _MemberT1>
-Struct(_MemberT0&& member_0, _MemberT1&& member_1):
-fields{ forward<_MemberT0>(member_0)},
-super_type{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Class {
-JaktInternal::DynamicArray<parser::ParsedField> fields;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> super_type;
-template<typename _MemberT0, typename _MemberT1>
-Class(_MemberT0&& member_0, _MemberT1&& member_1):
-fields{ forward<_MemberT0>(member_0)},
-super_type{ forward<_MemberT1>(member_1)}
-{}
-};
-struct ValueEnum {
-NonnullRefPtr<typename parser::ParsedType> underlying_type;
-JaktInternal::DynamicArray<parser::ValueEnumVariant> variants;
-template<typename _MemberT0, typename _MemberT1>
-ValueEnum(_MemberT0&& member_0, _MemberT1&& member_1):
-underlying_type{ forward<_MemberT0>(member_0)},
-variants{ forward<_MemberT1>(member_1)}
-{}
-};
-struct SumEnum {
-bool is_boxed;
-JaktInternal::DynamicArray<parser::ParsedField> fields;
-JaktInternal::DynamicArray<parser::SumEnumVariant> variants;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-SumEnum(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
-is_boxed{ forward<_MemberT0>(member_0)},
-fields{ forward<_MemberT1>(member_1)},
-variants{ forward<_MemberT2>(member_2)}
-{}
-};
-struct Garbage {
-};
-}
-struct RecordType : public Variant<RecordType_Details::Struct, RecordType_Details::Class, RecordType_Details::ValueEnum, RecordType_Details::SumEnum, RecordType_Details::Garbage> {
-using Variant<RecordType_Details::Struct, RecordType_Details::Class, RecordType_Details::ValueEnum, RecordType_Details::SumEnum, RecordType_Details::Garbage>::Variant;
-    using Struct = RecordType_Details::Struct;
-    using Class = RecordType_Details::Class;
-    using ValueEnum = RecordType_Details::ValueEnum;
-    using SumEnum = RecordType_Details::SumEnum;
-    using Garbage = RecordType_Details::Garbage;
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_expression(bool const allow_assignments, bool const allow_newlines);
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_operator(bool const allow_assignments);
+ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parse_for_statement();
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_operand();
+ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parse_sum_enum_body(parser::ParsedRecord const partial_enum, parser::DefinitionLinkage const definition_linkage, bool const is_boxed);
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedCapture>> parse_captures();
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_number(lexer::LiteralPrefix const prefix, DeprecatedString const number, lexer::LiteralSuffix suffix, utility::Span const span);
+ErrorOr<parser::ParsedModuleImport> parse_module_import();
+ErrorOr<parser::ParsedRecord> parse_record(parser::DefinitionLinkage const definition_linkage);
+lexer::Token peek(size_t const steps) const;
+ErrorOr<void> error_with_hint(DeprecatedString const message, utility::Span const span, DeprecatedString const hint, utility::Span const hint_span);
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_shorthand_array_or_dictionary();
+ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_shorthand_tuple();
+bool eol() const;
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_array_or_dictionary_literal();
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchPattern>> parse_match_patterns();
+ErrorOr<void> parse_import(parser::ParsedNamespace& parent);
+ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parse_statement(bool const inside_block);
+ErrorOr<parser::ParsedField> parse_field(parser::Visibility const visibility);
+ErrorOr<DeprecatedString> parse_argument_label();
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_ampersand();
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>> parse_include_action();
+ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_try_block();
+ErrorOr<JaktInternal::DynamicArray<parser::ParsedGenericParameter>> parse_generic_parameters();
+ErrorOr<parser::ParsedRecord> parse_struct(parser::DefinitionLinkage const definition_linkage);
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>>> parse_trait_list();
 ErrorOr<DeprecatedString> debug_description() const;
-DeprecatedString record_type_name() const;
-};
-struct ParsedRecord {
+};struct VisibilityRestriction {
   public:
-DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<parser::ParsedGenericParameter> generic_parameters;parser::DefinitionLinkage definition_linkage;JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> implements_list;JaktInternal::DynamicArray<parser::ParsedMethod> methods;parser::RecordType record_type;JaktInternal::Optional<DeprecatedString> external_name;ParsedRecord(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<parser::ParsedGenericParameter> a_generic_parameters, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>> a_implements_list, JaktInternal::DynamicArray<parser::ParsedMethod> a_methods, parser::RecordType a_record_type, JaktInternal::Optional<DeprecatedString> a_external_name);
+JaktInternal::DynamicArray<DeprecatedString> namespace_;DeprecatedString name;VisibilityRestriction(JaktInternal::DynamicArray<DeprecatedString> a_namespace_, DeprecatedString a_name);
 
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace ImportList_Details {
-struct List{
-JaktInternal::DynamicArray<parser::ImportName> value;
-template<typename _MemberT0>
-List(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-struct All {
-};
-}
-struct ImportList : public Variant<ImportList_Details::List, ImportList_Details::All> {
-using Variant<ImportList_Details::List, ImportList_Details::All>::Variant;
-    using List = ImportList_Details::List;
-    using All = ImportList_Details::All;
-ErrorOr<DeprecatedString> debug_description() const;
-ErrorOr<void> add(parser::ImportName const name);
-bool is_empty() const;
-};
-struct ParsedModuleImport {
+ErrorOr<DeprecatedString> debug_description() const;
+};struct SumEnumVariant {
   public:
-parser::ImportName module_name;JaktInternal::Optional<parser::ImportName> alias_name;parser::ImportList import_list;ParsedModuleImport(parser::ImportName a_module_name, JaktInternal::Optional<parser::ImportName> a_alias_name, parser::ImportList a_import_list);
+DeprecatedString name;utility::Span span;JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedVarDecl>> params;SumEnumVariant(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedVarDecl>> a_params);
 
-bool is_equivalent_to(parser::ParsedModuleImport const other) const;
-bool has_same_alias_than(parser::ParsedModuleImport const other) const;
-bool has_same_import_semantics(parser::ParsedModuleImport const other) const;
-ErrorOr<void> merge_import_list(parser::ImportList const list);
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace IncludeAction_Details {
-struct Define {
+};namespace ParsedCapture_Details {
+struct ByValue {
 DeprecatedString name;
 utility::Span span;
-DeprecatedString value;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-Define(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+template<typename _MemberT0, typename _MemberT1>
+ByValue(_MemberT0&& member_0, _MemberT1&& member_1):
 name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)},
-value{ forward<_MemberT2>(member_2)}
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Undefine {
+struct ByReference {
 DeprecatedString name;
 utility::Span span;
 template<typename _MemberT0, typename _MemberT1>
-Undefine(_MemberT0&& member_0, _MemberT1&& member_1):
+ByReference(_MemberT0&& member_0, _MemberT1&& member_1):
 name{ forward<_MemberT0>(member_0)},
 span{ forward<_MemberT1>(member_1)}
 {}
 };
-}
-struct IncludeAction : public Variant<IncludeAction_Details::Define, IncludeAction_Details::Undefine> {
-using Variant<IncludeAction_Details::Define, IncludeAction_Details::Undefine>::Variant;
-    using Define = IncludeAction_Details::Define;
-    using Undefine = IncludeAction_Details::Undefine;
-ErrorOr<DeprecatedString> debug_description() const;
-};
-struct ParsedParameter {
-  public:
-bool requires_label;parser::ParsedVariable variable;JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_argument;utility::Span span;bool equals(parser::ParsedParameter const rhs_param) const;
-ParsedParameter(bool a_requires_label, parser::ParsedVariable a_variable, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_argument, utility::Span a_span);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct SumEnumVariant {
-  public:
-DeprecatedString name;utility::Span span;JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedVarDecl>> params;SumEnumVariant(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedVarDecl>> a_params);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedField {
-  public:
-parser::ParsedVarDecl var_decl;parser::Visibility visibility;JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_value;ParsedField(parser::ParsedVarDecl a_var_decl, parser::Visibility a_visibility, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_value);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct VisibilityRestriction {
-  public:
-JaktInternal::DynamicArray<DeprecatedString> namespace_;DeprecatedString name;VisibilityRestriction(JaktInternal::DynamicArray<DeprecatedString> a_namespace_, DeprecatedString a_name);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace ParsedMatchPattern_Details {
-struct EnumVariant {
-JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults;
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> variant_names;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments;
-utility::Span arguments_span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-EnumVariant(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-defaults{ forward<_MemberT0>(member_0)},
-variant_names{ forward<_MemberT1>(member_1)},
-variant_arguments{ forward<_MemberT2>(member_2)},
-arguments_span{ forward<_MemberT3>(member_3)}
-{}
-};
-struct Expression{
-JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults;
-NonnullRefPtr<typename parser::ParsedExpression> value;
+struct ByMutableReference {
+DeprecatedString name;
+utility::Span span;
 template<typename _MemberT0, typename _MemberT1>
-Expression(_MemberT0&& member_0, _MemberT1&& member_1):
-defaults{ forward<_MemberT0>(member_0)},
-value{ forward<_MemberT1>(member_1)}
+ByMutableReference(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct CatchAll {
-JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> variant_arguments;
-utility::Span arguments_span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-CatchAll(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
-defaults{ forward<_MemberT0>(member_0)},
-variant_arguments{ forward<_MemberT1>(member_1)},
-arguments_span{ forward<_MemberT2>(member_2)}
+struct ByComptimeDependency {
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+ByComptimeDependency(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Invalid {
-JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> defaults;
-template<typename _MemberT0>
-Invalid(_MemberT0&& member_0):
-defaults{ forward<_MemberT0>(member_0)}
+struct AllByReference {
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+AllByReference(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
 }
-struct ParsedMatchPattern : public Variant<ParsedMatchPattern_Details::EnumVariant, ParsedMatchPattern_Details::Expression, ParsedMatchPattern_Details::CatchAll, ParsedMatchPattern_Details::Invalid> {
-using Variant<ParsedMatchPattern_Details::EnumVariant, ParsedMatchPattern_Details::Expression, ParsedMatchPattern_Details::CatchAll, ParsedMatchPattern_Details::Invalid>::Variant;
-    using EnumVariant = ParsedMatchPattern_Details::EnumVariant;
-    using Expression = ParsedMatchPattern_Details::Expression;
-    using CatchAll = ParsedMatchPattern_Details::CatchAll;
-    using Invalid = ParsedMatchPattern_Details::Invalid;
+struct ParsedCapture : public Variant<ParsedCapture_Details::ByValue, ParsedCapture_Details::ByReference, ParsedCapture_Details::ByMutableReference, ParsedCapture_Details::ByComptimeDependency, ParsedCapture_Details::AllByReference> {
+using Variant<ParsedCapture_Details::ByValue, ParsedCapture_Details::ByReference, ParsedCapture_Details::ByMutableReference, ParsedCapture_Details::ByComptimeDependency, ParsedCapture_Details::AllByReference>::Variant;
+    using ByValue = ParsedCapture_Details::ByValue;
+    using ByReference = ParsedCapture_Details::ByReference;
+    using ByMutableReference = ParsedCapture_Details::ByMutableReference;
+    using ByComptimeDependency = ParsedCapture_Details::ByComptimeDependency;
+    using AllByReference = ParsedCapture_Details::AllByReference;
 ErrorOr<DeprecatedString> debug_description() const;
-JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const& defaults() const { switch(this->index()) {case 0 /* EnumVariant */: return this->template get<ParsedMatchPattern::EnumVariant>().defaults;
-case 1 /* Expression */: return this->template get<ParsedMatchPattern::Expression>().defaults;
-case 2 /* CatchAll */: return this->template get<ParsedMatchPattern::CatchAll>().defaults;
-case 3 /* Invalid */: return this->template get<ParsedMatchPattern::Invalid>().defaults;
+DeprecatedString const& name() const { switch(this->index()) {case 0 /* ByValue */: return this->template get<ParsedCapture::ByValue>().name;
+case 1 /* ByReference */: return this->template get<ParsedCapture::ByReference>().name;
+case 2 /* ByMutableReference */: return this->template get<ParsedCapture::ByMutableReference>().name;
+case 3 /* ByComptimeDependency */: return this->template get<ParsedCapture::ByComptimeDependency>().name;
+case 4 /* AllByReference */: return this->template get<ParsedCapture::AllByReference>().name;
+default: VERIFY_NOT_REACHED();
+}
+}
+utility::Span const& span() const { switch(this->index()) {case 0 /* ByValue */: return this->template get<ParsedCapture::ByValue>().span;
+case 1 /* ByReference */: return this->template get<ParsedCapture::ByReference>().span;
+case 2 /* ByMutableReference */: return this->template get<ParsedCapture::ByMutableReference>().span;
+case 3 /* ByComptimeDependency */: return this->template get<ParsedCapture::ByComptimeDependency>().span;
+case 4 /* AllByReference */: return this->template get<ParsedCapture::AllByReference>().span;
 default: VERIFY_NOT_REACHED();
 }
 }
-bool equals(parser::ParsedMatchPattern const rhs_parsed_match_pattern) const;
-bool is_equal_pattern(parser::ParsedMatchPattern const rhs_parsed_match_pattern) const;
-bool defaults_equal(JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const defaults) const;
 };
-struct ParsedAttribute {
+struct ParsedAlias {
   public:
-DeprecatedString name;utility::Span span;JaktInternal::Optional<DeprecatedString> assigned_value;JaktInternal::DynamicArray<parser::ParsedAttributeArgument> arguments;ParsedAttribute(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<DeprecatedString> a_assigned_value, JaktInternal::DynamicArray<parser::ParsedAttributeArgument> a_arguments);
+JaktInternal::Optional<parser::ParsedName> alias_name;JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> target;ParsedAlias(JaktInternal::Optional<parser::ParsedName> a_alias_name, JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> a_target);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace ParsedCapture_Details {
-struct ByValue {
+};namespace ParsedType_Details {
+struct Name {
 DeprecatedString name;
 utility::Span span;
 template<typename _MemberT0, typename _MemberT1>
-ByValue(_MemberT0&& member_0, _MemberT1&& member_1):
+Name(_MemberT0&& member_0, _MemberT1&& member_1):
 name{ forward<_MemberT0>(member_0)},
 span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct ByReference {
+struct NamespacedName {
 DeprecatedString name;
+JaktInternal::DynamicArray<DeprecatedString> namespaces;
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> params;
 utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-ByReference(_MemberT0&& member_0, _MemberT1&& member_1):
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+NamespacedName(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
 name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+namespaces{ forward<_MemberT1>(member_1)},
+params{ forward<_MemberT2>(member_2)},
+span{ forward<_MemberT3>(member_3)}
 {}
 };
-struct ByMutableReference {
+struct GenericType {
 DeprecatedString name;
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> generic_parameters;
 utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-ByMutableReference(_MemberT0&& member_0, _MemberT1&& member_1):
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+GenericType(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
 name{ forward<_MemberT0>(member_0)},
+generic_parameters{ forward<_MemberT1>(member_1)},
+span{ forward<_MemberT2>(member_2)}
+{}
+};
+struct JaktArray {
+NonnullRefPtr<typename parser::ParsedType> inner;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+JaktArray(_MemberT0&& member_0, _MemberT1&& member_1):
+inner{ forward<_MemberT0>(member_0)},
 span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct ByComptimeDependency {
-DeprecatedString name;
+struct Dictionary {
+NonnullRefPtr<typename parser::ParsedType> key;
+NonnullRefPtr<typename parser::ParsedType> value;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+Dictionary(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+key{ forward<_MemberT0>(member_0)},
+value{ forward<_MemberT1>(member_1)},
+span{ forward<_MemberT2>(member_2)}
+{}
+};
+struct JaktTuple {
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> types;
 utility::Span span;
 template<typename _MemberT0, typename _MemberT1>
-ByComptimeDependency(_MemberT0&& member_0, _MemberT1&& member_1):
-name{ forward<_MemberT0>(member_0)},
+JaktTuple(_MemberT0&& member_0, _MemberT1&& member_1):
+types{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct Set {
+NonnullRefPtr<typename parser::ParsedType> inner;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Set(_MemberT0&& member_0, _MemberT1&& member_1):
+inner{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct Optional {
+NonnullRefPtr<typename parser::ParsedType> inner;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Optional(_MemberT0&& member_0, _MemberT1&& member_1):
+inner{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct Reference {
+NonnullRefPtr<typename parser::ParsedType> inner;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Reference(_MemberT0&& member_0, _MemberT1&& member_1):
+inner{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct MutableReference {
+NonnullRefPtr<typename parser::ParsedType> inner;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+MutableReference(_MemberT0&& member_0, _MemberT1&& member_1):
+inner{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct RawPtr {
+NonnullRefPtr<typename parser::ParsedType> inner;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+RawPtr(_MemberT0&& member_0, _MemberT1&& member_1):
+inner{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct WeakPtr {
+NonnullRefPtr<typename parser::ParsedType> inner;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+WeakPtr(_MemberT0&& member_0, _MemberT1&& member_1):
+inner{ forward<_MemberT0>(member_0)},
 span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct AllByReference {
-DeprecatedString name;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-AllByReference(_MemberT0&& member_0, _MemberT1&& member_1):
-name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
+struct Function {
+JaktInternal::DynamicArray<parser::ParsedParameter> params;
+bool can_throw;
+NonnullRefPtr<typename parser::ParsedType> return_type;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+Function(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+params{ forward<_MemberT0>(member_0)},
+can_throw{ forward<_MemberT1>(member_1)},
+return_type{ forward<_MemberT2>(member_2)},
+span{ forward<_MemberT3>(member_3)}
+{}
+};
+struct Empty {
 };
 }
-struct ParsedCapture : public Variant<ParsedCapture_Details::ByValue, ParsedCapture_Details::ByReference, ParsedCapture_Details::ByMutableReference, ParsedCapture_Details::ByComptimeDependency, ParsedCapture_Details::AllByReference> {
-using Variant<ParsedCapture_Details::ByValue, ParsedCapture_Details::ByReference, ParsedCapture_Details::ByMutableReference, ParsedCapture_Details::ByComptimeDependency, ParsedCapture_Details::AllByReference>::Variant;
-    using ByValue = ParsedCapture_Details::ByValue;
-    using ByReference = ParsedCapture_Details::ByReference;
-    using ByMutableReference = ParsedCapture_Details::ByMutableReference;
-    using ByComptimeDependency = ParsedCapture_Details::ByComptimeDependency;
-    using AllByReference = ParsedCapture_Details::AllByReference;
-ErrorOr<DeprecatedString> debug_description() const;
-DeprecatedString const& name() const { switch(this->index()) {case 0 /* ByValue */: return this->template get<ParsedCapture::ByValue>().name;
-case 1 /* ByReference */: return this->template get<ParsedCapture::ByReference>().name;
-case 2 /* ByMutableReference */: return this->template get<ParsedCapture::ByMutableReference>().name;
-case 3 /* ByComptimeDependency */: return this->template get<ParsedCapture::ByComptimeDependency>().name;
-case 4 /* AllByReference */: return this->template get<ParsedCapture::AllByReference>().name;
-default: VERIFY_NOT_REACHED();
-}
-}
-utility::Span const& span() const { switch(this->index()) {case 0 /* ByValue */: return this->template get<ParsedCapture::ByValue>().span;
-case 1 /* ByReference */: return this->template get<ParsedCapture::ByReference>().span;
-case 2 /* ByMutableReference */: return this->template get<ParsedCapture::ByMutableReference>().span;
-case 3 /* ByComptimeDependency */: return this->template get<ParsedCapture::ByComptimeDependency>().span;
-case 4 /* AllByReference */: return this->template get<ParsedCapture::AllByReference>().span;
-default: VERIFY_NOT_REACHED();
-}
+struct ParsedType : public Variant<ParsedType_Details::Name, ParsedType_Details::NamespacedName, ParsedType_Details::GenericType, ParsedType_Details::JaktArray, ParsedType_Details::Dictionary, ParsedType_Details::JaktTuple, ParsedType_Details::Set, ParsedType_Details::Optional, ParsedType_Details::Reference, ParsedType_Details::MutableReference, ParsedType_Details::RawPtr, ParsedType_Details::WeakPtr, ParsedType_Details::Function, ParsedType_Details::Empty>, public RefCounted<ParsedType> {
+using Variant<ParsedType_Details::Name, ParsedType_Details::NamespacedName, ParsedType_Details::GenericType, ParsedType_Details::JaktArray, ParsedType_Details::Dictionary, ParsedType_Details::JaktTuple, ParsedType_Details::Set, ParsedType_Details::Optional, ParsedType_Details::Reference, ParsedType_Details::MutableReference, ParsedType_Details::RawPtr, ParsedType_Details::WeakPtr, ParsedType_Details::Function, ParsedType_Details::Empty>::Variant;
+    using Name = ParsedType_Details::Name;
+    using NamespacedName = ParsedType_Details::NamespacedName;
+    using GenericType = ParsedType_Details::GenericType;
+    using JaktArray = ParsedType_Details::JaktArray;
+    using Dictionary = ParsedType_Details::Dictionary;
+    using JaktTuple = ParsedType_Details::JaktTuple;
+    using Set = ParsedType_Details::Set;
+    using Optional = ParsedType_Details::Optional;
+    using Reference = ParsedType_Details::Reference;
+    using MutableReference = ParsedType_Details::MutableReference;
+    using RawPtr = ParsedType_Details::RawPtr;
+    using WeakPtr = ParsedType_Details::WeakPtr;
+    using Function = ParsedType_Details::Function;
+    using Empty = ParsedType_Details::Empty;
+template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
+return adopt_nonnull_ref_or_enomem(new (nothrow) ParsedType(V(forward<Args>(args)...)));
 }
+ErrorOr<DeprecatedString> debug_description() const;
+bool equals(NonnullRefPtr<typename parser::ParsedType> const rhs_parsed_type) const;
+utility::Span span() const;
 };
-struct ParsedAttributeArgument {
+struct ParsedNamespace {
   public:
-DeprecatedString name;utility::Span span;JaktInternal::Optional<DeprecatedString> assigned_value;ParsedAttributeArgument(DeprecatedString a_name, utility::Span a_span, JaktInternal::Optional<DeprecatedString> a_assigned_value);
+JaktInternal::Optional<DeprecatedString> name;JaktInternal::Optional<utility::Span> name_span;JaktInternal::DynamicArray<parser::ParsedFunction> functions;JaktInternal::DynamicArray<parser::ParsedRecord> records;JaktInternal::DynamicArray<parser::ParsedTrait> traits;JaktInternal::DynamicArray<parser::ParsedExternalTraitImplementation> external_trait_implementations;JaktInternal::DynamicArray<parser::ParsedNamespace> namespaces;JaktInternal::DynamicArray<parser::ParsedAlias> aliases;JaktInternal::DynamicArray<parser::ParsedModuleImport> module_imports;JaktInternal::DynamicArray<parser::ParsedExternImport> extern_imports;JaktInternal::Optional<DeprecatedString> import_path_if_extern;JaktInternal::DynamicArray<parser::IncludeAction> generating_import_extern_before_include;JaktInternal::DynamicArray<parser::IncludeAction> generating_import_extern_after_include;ErrorOr<void> add_child_namespace(parser::ParsedNamespace const namespace_);
+ParsedNamespace(JaktInternal::Optional<DeprecatedString> a_name, JaktInternal::Optional<utility::Span> a_name_span, JaktInternal::DynamicArray<parser::ParsedFunction> a_functions, JaktInternal::DynamicArray<parser::ParsedRecord> a_records, JaktInternal::DynamicArray<parser::ParsedTrait> a_traits, JaktInternal::DynamicArray<parser::ParsedExternalTraitImplementation> a_external_trait_implementations, JaktInternal::DynamicArray<parser::ParsedNamespace> a_namespaces, JaktInternal::DynamicArray<parser::ParsedAlias> a_aliases, JaktInternal::DynamicArray<parser::ParsedModuleImport> a_module_imports, JaktInternal::DynamicArray<parser::ParsedExternImport> a_extern_imports, JaktInternal::Optional<DeprecatedString> a_import_path_if_extern, JaktInternal::DynamicArray<parser::IncludeAction> a_generating_import_extern_before_include, JaktInternal::DynamicArray<parser::IncludeAction> a_generating_import_extern_after_include);
 
+bool is_equivalent_to(parser::ParsedNamespace const other) const;
+ErrorOr<void> add_extern_import(parser::ParsedExternImport const import_);
+ErrorOr<void> add_alias(parser::ParsedAlias const alias);
+ErrorOr<void> merge_with(parser::ParsedNamespace const namespace_);
+ErrorOr<void> add_module_import(parser::ParsedModuleImport const import_);
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedNameWithGenericParameters {
+};struct ParsedExternImport {
   public:
-DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> generic_parameters;ParsedNameWithGenericParameters(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> a_generic_parameters);
+bool is_c;parser::ParsedNamespace assigned_namespace;JaktInternal::DynamicArray<parser::IncludeAction> before_include;JaktInternal::DynamicArray<parser::IncludeAction> after_include;ErrorOr<bool> is_equivalent_to(parser::ParsedExternImport const other) const;
+ParsedExternImport(bool a_is_c, parser::ParsedNamespace a_assigned_namespace, JaktInternal::DynamicArray<parser::IncludeAction> a_before_include, JaktInternal::DynamicArray<parser::IncludeAction> a_after_include);
 
+DeprecatedString get_path() const;
+DeprecatedString get_name() const;
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace ArgumentStoreLevel_Details {
-struct InObject {
-size_t argument_index;
-template<typename _MemberT0>
-InObject(_MemberT0&& member_0):
-argument_index{ forward<_MemberT0>(member_0)}
-{}
-};
-struct InStaticStorage {
-};
-}
-struct ArgumentStoreLevel : public Variant<ArgumentStoreLevel_Details::InObject, ArgumentStoreLevel_Details::InStaticStorage> {
-using Variant<ArgumentStoreLevel_Details::InObject, ArgumentStoreLevel_Details::InStaticStorage>::Variant;
-    using InObject = ArgumentStoreLevel_Details::InObject;
-    using InStaticStorage = ArgumentStoreLevel_Details::InStaticStorage;
+};struct ParsedField {
+  public:
+parser::ParsedVarDecl var_decl;parser::Visibility visibility;JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_value;ParsedField(parser::ParsedVarDecl a_var_decl, parser::Visibility a_visibility, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_value);
+
 ErrorOr<DeprecatedString> debug_description() const;
-};
-namespace ParsedStatement_Details {
+};namespace ParsedStatement_Details {
 struct Expression {
 NonnullRefPtr<typename parser::ParsedExpression> expr;
 utility::Span span;
@@ -1495,181 +1588,88 @@ value{ forward<_MemberT0>(member_0)}
 struct Return {
 JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> expr;
 utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Return(_MemberT0&& member_0, _MemberT1&& member_1):
-expr{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Throw {
-NonnullRefPtr<typename parser::ParsedExpression> expr;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Throw(_MemberT0&& member_0, _MemberT1&& member_1):
-expr{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Yield {
-NonnullRefPtr<typename parser::ParsedExpression> expr;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Yield(_MemberT0&& member_0, _MemberT1&& member_1):
-expr{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct InlineCpp {
-parser::ParsedBlock block;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-InlineCpp(_MemberT0&& member_0, _MemberT1&& member_1):
-block{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Guard {
-NonnullRefPtr<typename parser::ParsedExpression> expr;
-parser::ParsedBlock else_block;
-parser::ParsedBlock remaining_code;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-Guard(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-expr{ forward<_MemberT0>(member_0)},
-else_block{ forward<_MemberT1>(member_1)},
-remaining_code{ forward<_MemberT2>(member_2)},
-span{ forward<_MemberT3>(member_3)}
-{}
-};
-struct Garbage{
-utility::Span value;
-template<typename _MemberT0>
-Garbage(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-}
-struct ParsedStatement : public Variant<ParsedStatement_Details::Expression, ParsedStatement_Details::Defer, ParsedStatement_Details::UnsafeBlock, ParsedStatement_Details::DestructuringAssignment, ParsedStatement_Details::VarDecl, ParsedStatement_Details::If, ParsedStatement_Details::Block, ParsedStatement_Details::Loop, ParsedStatement_Details::While, ParsedStatement_Details::For, ParsedStatement_Details::Break, ParsedStatement_Details::Continue, ParsedStatement_Details::Return, ParsedStatement_Details::Throw, ParsedStatement_Details::Yield, ParsedStatement_Details::InlineCpp, ParsedStatement_Details::Guard, ParsedStatement_Details::Garbage>, public RefCounted<ParsedStatement> {
-using Variant<ParsedStatement_Details::Expression, ParsedStatement_Details::Defer, ParsedStatement_Details::UnsafeBlock, ParsedStatement_Details::DestructuringAssignment, ParsedStatement_Details::VarDecl, ParsedStatement_Details::If, ParsedStatement_Details::Block, ParsedStatement_Details::Loop, ParsedStatement_Details::While, ParsedStatement_Details::For, ParsedStatement_Details::Break, ParsedStatement_Details::Continue, ParsedStatement_Details::Return, ParsedStatement_Details::Throw, ParsedStatement_Details::Yield, ParsedStatement_Details::InlineCpp, ParsedStatement_Details::Guard, ParsedStatement_Details::Garbage>::Variant;
-    using Expression = ParsedStatement_Details::Expression;
-    using Defer = ParsedStatement_Details::Defer;
-    using UnsafeBlock = ParsedStatement_Details::UnsafeBlock;
-    using DestructuringAssignment = ParsedStatement_Details::DestructuringAssignment;
-    using VarDecl = ParsedStatement_Details::VarDecl;
-    using If = ParsedStatement_Details::If;
-    using Block = ParsedStatement_Details::Block;
-    using Loop = ParsedStatement_Details::Loop;
-    using While = ParsedStatement_Details::While;
-    using For = ParsedStatement_Details::For;
-    using Break = ParsedStatement_Details::Break;
-    using Continue = ParsedStatement_Details::Continue;
-    using Return = ParsedStatement_Details::Return;
-    using Throw = ParsedStatement_Details::Throw;
-    using Yield = ParsedStatement_Details::Yield;
-    using InlineCpp = ParsedStatement_Details::InlineCpp;
-    using Guard = ParsedStatement_Details::Guard;
-    using Garbage = ParsedStatement_Details::Garbage;
-template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
-return adopt_nonnull_ref_or_enomem(new (nothrow) ParsedStatement(V(forward<Args>(args)...)));
-}
-ErrorOr<DeprecatedString> debug_description() const;
-bool equals(NonnullRefPtr<typename parser::ParsedStatement> const rhs_statement) const;
-utility::Span span() const;
-};
-struct ParsedMethod {
-  public:
-parser::ParsedFunction parsed_function;parser::Visibility visibility;bool is_virtual;bool is_override;ParsedMethod(parser::ParsedFunction a_parsed_function, parser::Visibility a_visibility, bool a_is_virtual, bool a_is_override);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct ParsedTrait {
-  public:
-DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<parser::ParsedGenericParameter> generic_parameters;JaktInternal::DynamicArray<parser::ParsedFunction> methods;ParsedTrait(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<parser::ParsedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<parser::ParsedFunction> a_methods);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct Parser {
-  public:
-size_t index;JaktInternal::DynamicArray<lexer::Token> tokens;NonnullRefPtr<compiler::Compiler> compiler;bool can_have_trailing_closure;ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ValueEnumVariant>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parse_value_enum_body(parser::ParsedRecord const partial_enum, parser::DefinitionLinkage const definition_linkage);
-ErrorOr<JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>>> parse_type_parameter_list();
-ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parse_statement(bool const inside_block);
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_shorthand_array_or_dictionary();
-ErrorOr<parser::ParsedBlock> parse_fat_arrow();
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_typename();
-ErrorOr<void> error_with_hint(DeprecatedString const message, utility::Span const span, DeprecatedString const hint, utility::Span const hint_span);
-ErrorOr<parser::ParsedRecord> parse_class(parser::DefinitionLinkage const definition_linkage);
-bool eof() const;
-ErrorOr<parser::ParsedVarDeclTuple> parse_destructuring_assignment(bool const is_mutable);
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_match_expression();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_lambda();
-lexer::Token previous() const;
-ErrorOr<parser::ParsedBlock> parse_block();
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_longhand();
-ErrorOr<void> parse_attribute_list(JaktInternal::DynamicArray<parser::ParsedAttribute>& active_attributes);
-ErrorOr<void> error(DeprecatedString const message, utility::Span const span);
-ErrorOr<parser::ParsedRecord> parse_struct(parser::DefinitionLinkage const definition_linkage);
-bool eol() const;
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters>>> parse_trait_list();
-ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parse_struct_class_body(parser::DefinitionLinkage const definition_linkage, parser::Visibility const default_visibility, bool const is_class);
-ErrorOr<JaktInternal::DynamicArray<parser::EnumVariantPatternArgument>> parse_variant_arguments();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_set_literal();
-ErrorOr<parser::ParsedField> parse_field(parser::Visibility const visibility);
-void skip_newlines();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_asterisk();
-ErrorOr<JaktInternal::Tuple<JaktInternal::DynamicArray<parser::SumEnumVariant>,JaktInternal::DynamicArray<parser::ParsedField>,JaktInternal::DynamicArray<parser::ParsedMethod>>> parse_sum_enum_body(parser::ParsedRecord const partial_enum, parser::DefinitionLinkage const definition_linkage, bool const is_boxed);
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_shorthand_tuple();
-ErrorOr<parser::ParsedMatchPattern> parse_match_pattern();
-ErrorOr<void> parse_import(parser::ParsedNamespace& parent);
-ErrorOr<JaktInternal::Optional<parser::NumericConstant>> make_integer_numeric_constant(u64 const number, lexer::LiteralSuffix const suffix, utility::Span const span);
-ErrorOr<parser::ParsedRecord> parse_enum(parser::DefinitionLinkage const definition_linkage, bool const is_boxed);
-ErrorOr<parser::Visibility> parse_restricted_visibility_modifier();
-ErrorOr<parser::ParsedRecord> parse_record(parser::DefinitionLinkage const definition_linkage);
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedCapture>> parse_captures();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_try_block();
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchPattern>> parse_match_patterns();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_operand_postfix_operator(utility::Span const start, NonnullRefPtr<typename parser::ParsedExpression> const expr);
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedGenericParameter>> parse_generic_parameters();
-ErrorOr<parser::ParsedMethod> parse_method(parser::FunctionLinkage const linkage, parser::Visibility const visibility, bool const is_virtual, bool const is_override, bool const is_comptime, bool const is_destructor);
-ErrorOr<parser::ParsedExternalTraitImplementation> parse_external_trait_implementation();
-ErrorOr<DeprecatedString> parse_argument_label();
-ErrorOr<parser::ParsedTrait> parse_trait();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_number(lexer::LiteralPrefix const prefix, DeprecatedString const number, lexer::LiteralSuffix suffix, utility::Span const span);
-ErrorOr<void> apply_attributes(parser::ParsedFunction& parsed_function, JaktInternal::DynamicArray<parser::ParsedAttribute> const& active_attributes);
-ErrorOr<void> apply_attributes(parser::ParsedMethod& parsed_method, JaktInternal::DynamicArray<parser::ParsedAttribute> const& active_attributes);
-ErrorOr<void> apply_attributes(parser::ParsedRecord& parsed_record, JaktInternal::DynamicArray<parser::ParsedAttribute> const& active_attributes);
-utility::Span span(size_t const start, size_t const end) const;
-ErrorOr<parser::ParsedFunction> parse_function(parser::FunctionLinkage const linkage, parser::Visibility const visibility, bool const is_comptime, bool const is_destructor, bool const allow_missing_body);
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<parser::IncludeAction>>> parse_include_action();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_range();
-ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parse_guard_statement();
-ErrorOr<void> inject_token(lexer::Token const token);
-ErrorOr<JaktInternal::Optional<parser::ParsedAttribute>> parse_attribute();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_operator(bool const allow_assignments);
-ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parse_for_statement();
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedParameter>> parse_function_parameters();
-ErrorOr<JaktInternal::Optional<parser::ParsedCall>> parse_call();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_array_or_dictionary_literal();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_operand();
-static ErrorOr<parser::ParsedNamespace> parse(NonnullRefPtr<compiler::Compiler> const compiler, JaktInternal::DynamicArray<lexer::Token> const tokens);
-ErrorOr<parser::ParsedExternImport> parse_extern_import(parser::ParsedNamespace& parent);
-ErrorOr<parser::ParsedModuleImport> parse_module_import();
-ErrorOr<parser::ParsedNamespace> parse_namespace();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_ampersand();
-ErrorOr<JaktInternal::DynamicArray<parser::ParsedMatchCase>> parse_match_cases();
-ErrorOr<JaktInternal::Optional<parser::NumericConstant>> make_float_numeric_constant(f64 const number, lexer::LiteralSuffix const suffix, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_postfix_colon_colon(utility::Span const start, NonnullRefPtr<typename parser::ParsedExpression> const expr);
-Parser(size_t a_index, JaktInternal::DynamicArray<lexer::Token> a_tokens, NonnullRefPtr<compiler::Compiler> a_compiler, bool a_can_have_trailing_closure);
-
-ErrorOr<NonnullRefPtr<typename parser::ParsedStatement>> parse_if_statement();
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_shorthand_set();
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_operand_base();
-ErrorOr<parser::ParsedAlias> parse_using();
-lexer::Token current() const;
-ErrorOr<NonnullRefPtr<typename parser::ParsedExpression>> parse_expression(bool const allow_assignments, bool const allow_newlines);
-lexer::Token peek(size_t const steps) const;
-ErrorOr<NonnullRefPtr<typename parser::ParsedType>> parse_type_shorthand();
-utility::Span empty_span() const;
-ErrorOr<parser::ParsedVarDecl> parse_variable_declaration(bool const is_mutable);
+template<typename _MemberT0, typename _MemberT1>
+Return(_MemberT0&& member_0, _MemberT1&& member_1):
+expr{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct Throw {
+NonnullRefPtr<typename parser::ParsedExpression> expr;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Throw(_MemberT0&& member_0, _MemberT1&& member_1):
+expr{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct Yield {
+NonnullRefPtr<typename parser::ParsedExpression> expr;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Yield(_MemberT0&& member_0, _MemberT1&& member_1):
+expr{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct InlineCpp {
+parser::ParsedBlock block;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+InlineCpp(_MemberT0&& member_0, _MemberT1&& member_1):
+block{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct Guard {
+NonnullRefPtr<typename parser::ParsedExpression> expr;
+parser::ParsedBlock else_block;
+parser::ParsedBlock remaining_code;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+Guard(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+expr{ forward<_MemberT0>(member_0)},
+else_block{ forward<_MemberT1>(member_1)},
+remaining_code{ forward<_MemberT2>(member_2)},
+span{ forward<_MemberT3>(member_3)}
+{}
+};
+struct Garbage{
+utility::Span value;
+template<typename _MemberT0>
+Garbage(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+}
+struct ParsedStatement : public Variant<ParsedStatement_Details::Expression, ParsedStatement_Details::Defer, ParsedStatement_Details::UnsafeBlock, ParsedStatement_Details::DestructuringAssignment, ParsedStatement_Details::VarDecl, ParsedStatement_Details::If, ParsedStatement_Details::Block, ParsedStatement_Details::Loop, ParsedStatement_Details::While, ParsedStatement_Details::For, ParsedStatement_Details::Break, ParsedStatement_Details::Continue, ParsedStatement_Details::Return, ParsedStatement_Details::Throw, ParsedStatement_Details::Yield, ParsedStatement_Details::InlineCpp, ParsedStatement_Details::Guard, ParsedStatement_Details::Garbage>, public RefCounted<ParsedStatement> {
+using Variant<ParsedStatement_Details::Expression, ParsedStatement_Details::Defer, ParsedStatement_Details::UnsafeBlock, ParsedStatement_Details::DestructuringAssignment, ParsedStatement_Details::VarDecl, ParsedStatement_Details::If, ParsedStatement_Details::Block, ParsedStatement_Details::Loop, ParsedStatement_Details::While, ParsedStatement_Details::For, ParsedStatement_Details::Break, ParsedStatement_Details::Continue, ParsedStatement_Details::Return, ParsedStatement_Details::Throw, ParsedStatement_Details::Yield, ParsedStatement_Details::InlineCpp, ParsedStatement_Details::Guard, ParsedStatement_Details::Garbage>::Variant;
+    using Expression = ParsedStatement_Details::Expression;
+    using Defer = ParsedStatement_Details::Defer;
+    using UnsafeBlock = ParsedStatement_Details::UnsafeBlock;
+    using DestructuringAssignment = ParsedStatement_Details::DestructuringAssignment;
+    using VarDecl = ParsedStatement_Details::VarDecl;
+    using If = ParsedStatement_Details::If;
+    using Block = ParsedStatement_Details::Block;
+    using Loop = ParsedStatement_Details::Loop;
+    using While = ParsedStatement_Details::While;
+    using For = ParsedStatement_Details::For;
+    using Break = ParsedStatement_Details::Break;
+    using Continue = ParsedStatement_Details::Continue;
+    using Return = ParsedStatement_Details::Return;
+    using Throw = ParsedStatement_Details::Throw;
+    using Yield = ParsedStatement_Details::Yield;
+    using InlineCpp = ParsedStatement_Details::InlineCpp;
+    using Guard = ParsedStatement_Details::Guard;
+    using Garbage = ParsedStatement_Details::Garbage;
+template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
+return adopt_nonnull_ref_or_enomem(new (nothrow) ParsedStatement(V(forward<Args>(args)...)));
+}
 ErrorOr<DeprecatedString> debug_description() const;
-};template <typename T>
+bool equals(NonnullRefPtr<typename parser::ParsedStatement> const rhs_statement) const;
+utility::Span span() const;
+};
+template <typename T>
 T u64_to_float(u64 const number);
 }
 } // namespace Jakt
@@ -1691,266 +1691,266 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedVarDecl> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedVarDecl const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ValueEnumVariant> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ValueEnumVariant const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::NumericConstant> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::NumericConstant const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedMatchPattern> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedMatchPattern const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedCall> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedCall const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedTrait> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedTrait const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::TypeCast> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::TypeCast const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::BinaryOperator> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::BinaryOperator const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedType> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedType const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedAttribute> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedAttribute const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::UnaryOperator> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::UnaryOperator const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::DefinitionLinkage> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::DefinitionLinkage const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::BinaryOperator> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::BinaryOperator const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::RecordType> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::RecordType const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::EnumVariantPatternArgument> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::EnumVariantPatternArgument const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedRecord> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedRecord const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedExpression> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedExpression const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedAttributeArgument> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedAttributeArgument const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedPatternDefault> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedPatternDefault const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ArgumentStoreLevel> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ArgumentStoreLevel const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedExternalTraitImplementation> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedExternalTraitImplementation const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedNameWithGenericParameters> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedNameWithGenericParameters const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedVariable> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedVariable const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::TypeCast> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::TypeCast const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedGenericParameter> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedGenericParameter const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedVarDecl> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedVarDecl const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedName> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedName const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ImportName> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ImportName const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedAlias> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedAlias const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedName> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedName const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::FunctionType> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::FunctionType const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedVariable> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedVariable const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::Visibility> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::Visibility const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::NumericConstant> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::NumericConstant const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::FunctionLinkage> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::FunctionLinkage const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedVarDeclTuple> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedVarDeclTuple const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedFunction> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedFunction const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedCall> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedCall const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ImportName> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ImportName const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::UnaryOperator> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::UnaryOperator const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedVarDeclTuple> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedVarDeclTuple const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::EnumVariantPatternArgument> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::EnumVariantPatternArgument const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ValueEnumVariant> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ValueEnumVariant const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedExpression> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedExpression const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedNamespace> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedNamespace const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::IncludeAction> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::IncludeAction const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedExternImport> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedExternImport const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ImportList> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ImportList const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::DefinitionLinkage> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::DefinitionLinkage const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedModuleImport> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedModuleImport const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::RecordType> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::RecordType const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedGenericParameter> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedGenericParameter const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedRecord> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedRecord const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedPatternDefault> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedPatternDefault const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ImportList> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ImportList const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedExternalTraitImplementation> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedExternalTraitImplementation const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedModuleImport> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedModuleImport const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::Visibility> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::Visibility const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::IncludeAction> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::IncludeAction const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::FunctionType> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::FunctionType const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedParameter> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedParameter const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::FunctionLinkage> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::FunctionLinkage const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::SumEnumVariant> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::SumEnumVariant const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedFunction> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedFunction const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedField> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedField const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedMethod> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedMethod const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::VisibilityRestriction> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::VisibilityRestriction const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedParameter> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedParameter const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedMatchPattern> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedMatchPattern const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::Parser> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::Parser const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedAttribute> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedAttribute const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::VisibilityRestriction> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::VisibilityRestriction const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedCapture> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedCapture const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::SumEnumVariant> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::SumEnumVariant const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedAttributeArgument> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedAttributeArgument const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedCapture> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedCapture const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedNameWithGenericParameters> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedNameWithGenericParameters const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedAlias> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedAlias const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ArgumentStoreLevel> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ArgumentStoreLevel const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedType> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedType const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedStatement> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedStatement const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedNamespace> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedNamespace const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedMethod> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedMethod const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedExternImport> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedExternImport const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::ParsedTrait> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedTrait const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedField> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedField const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::parser::Parser> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::Parser const& value) {
+template<>struct Jakt::Formatter<Jakt::parser::ParsedStatement> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::parser::ParsedStatement const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
diff --git a/bootstrap/stage0/project.cpp b/bootstrap/stage0/project.cpp
index 1b025fe4c..74572c0e4 100644
--- a/bootstrap/stage0/project.cpp
+++ b/bootstrap/stage0/project.cpp
@@ -6,6 +6,14 @@ JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\"", name));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<void> project::Project::create_template_cmake_lists(DeprecatedString const project_directory) const {
+{
+DeprecatedString const cml_contents = ((((Jakt::DeprecatedString("cmake_minimum_required(VERSION 3.20)\nproject("sv) + ((*this).name)) + Jakt::DeprecatedString("\n   VERSION 1.0.0\n   LANGUAGES CXX\n)\n\nfind_package(Jakt REQUIRED)\n\nadd_jakt_executable("sv)) + ((*this).name)) + Jakt::DeprecatedString("\n   MAIN_SOURCE src/main.jakt\n   MODULE_SOURCES\n     src/second_module.jakt\n)\n"sv));
+TRY((utility::write_to_file(cml_contents,(project_directory + Jakt::DeprecatedString("/CMakeLists.txt"sv)))));
+}
+return {};
+}
+
 ErrorOr<void> project::Project::populate() const {
 {
 DeprecatedString const current_directory = TRY((jakt__platform__unknown_fs::current_directory()));
@@ -35,16 +43,6 @@ TRY((utility::write_to_file(readme_text,(project_directory + Jakt::DeprecatedStr
 return {};
 }
 
-project::Project::Project(DeprecatedString a_name) :name(move(a_name)){}
-
-ErrorOr<void> project::Project::create_template_cmake_lists(DeprecatedString const project_directory) const {
-{
-DeprecatedString const cml_contents = ((((Jakt::DeprecatedString("cmake_minimum_required(VERSION 3.20)\nproject("sv) + ((*this).name)) + Jakt::DeprecatedString("\n   VERSION 1.0.0\n   LANGUAGES CXX\n)\n\nfind_package(Jakt REQUIRED)\n\nadd_jakt_executable("sv)) + ((*this).name)) + Jakt::DeprecatedString("\n   MAIN_SOURCE src/main.jakt\n   MODULE_SOURCES\n     src/second_module.jakt\n)\n"sv));
-TRY((utility::write_to_file(cml_contents,(project_directory + Jakt::DeprecatedString("/CMakeLists.txt"sv)))));
-}
-return {};
-}
-
 ErrorOr<void> project::Project::create_sample_jakt_files(DeprecatedString const project_directory) const {
 {
 DeprecatedString const main_jakt = Jakt::DeprecatedString("import second_module { get_string }\n\nfn main() throws -> c_int {\n    println(\"{}!\", get_string())\n    return 0\n}\n"sv);
@@ -55,5 +53,7 @@ TRY((utility::write_to_file(second_module_jakt,(project_directory + Jakt::Deprec
 return {};
 }
 
+project::Project::Project(DeprecatedString a_name) :name(move(a_name)){}
+
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/project.h b/bootstrap/stage0/project.h
index 5c875506e..ae0c87a54 100644
--- a/bootstrap/stage0/project.h
+++ b/bootstrap/stage0/project.h
@@ -7,12 +7,12 @@ namespace Jakt {
 namespace project {
 struct Project {
   public:
-DeprecatedString name;ErrorOr<void> populate() const;
+DeprecatedString name;ErrorOr<void> create_template_cmake_lists(DeprecatedString const project_directory) const;
+ErrorOr<void> populate() const;
 ErrorOr<void> create_readme(DeprecatedString const project_directory) const;
+ErrorOr<void> create_sample_jakt_files(DeprecatedString const project_directory) const;
 Project(DeprecatedString a_name);
 
-ErrorOr<void> create_template_cmake_lists(DeprecatedString const project_directory) const;
-ErrorOr<void> create_sample_jakt_files(DeprecatedString const project_directory) const;
 ErrorOr<DeprecatedString> debug_description() const;
 };}
 } // namespace Jakt
diff --git a/bootstrap/stage0/repl.cpp b/bootstrap/stage0/repl.cpp
index 4dcdef3f1..62fa46048 100644
--- a/bootstrap/stage0/repl.cpp
+++ b/bootstrap/stage0/repl.cpp
@@ -412,53 +412,6 @@ return JaktInternal::ExplicitValue(Jakt::DeprecatedString("<Unimplemented>"sv));
 }
 }
 
-ErrorOr<DeprecatedString> repl::Editor::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Editor("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("standard_input_file: {}, ", standard_input_file));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("line_pointer: {}, ", line_pointer));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("prompt: \"{}\"", prompt));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<repl::Editor> repl::Editor::create(DeprecatedString const prompt) {
-{
-FILE* std_in = fopen(((Jakt::DeprecatedString("/dev/stdin"sv)).characters()),((Jakt::DeprecatedString("r"sv)).characters()));
-if ((std_in == utility::null<FILE>())){
-warnln(Jakt::DeprecatedString("Could not open /dev/stdin for reading"sv));
-return Error::from_errno(static_cast<i32>(42));
-}
-repl::Editor const editor = repl::Editor(std_in,utility::allocate<char>(static_cast<size_t>(4096ULL)),prompt);
-return (editor);
-}
-}
-
-void repl::Editor::destroy() {
-{
-fclose(((*this).standard_input_file));
-{
-free(line_pointer);
-}
-
-}
-}
-
-repl::Editor::Editor(FILE* a_standard_input_file, char* a_line_pointer, DeprecatedString a_prompt) :standard_input_file(move(a_standard_input_file)), line_pointer(move(a_line_pointer)), prompt(move(a_prompt)){}
-
-ErrorOr<repl::LineResult> repl::Editor::get_line() {
-{
-warn(Jakt::DeprecatedString("{}"sv),((*this).prompt));
-DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
-{
-char* const c_string = fgets(((*this).line_pointer),static_cast<size_t>(4096ULL),((*this).standard_input_file));
-if ((c_string == utility::null<char>())){
-return ( repl::LineResult { typename repl::LineResult::Eof() } );
-}
-TRY((((builder).append_c_string(c_string))));
-}
-
-return ( repl::LineResult { typename repl::LineResult::Line(TRY((((builder).to_string())))) } );
-}
-}
-
 ErrorOr<DeprecatedString> repl::REPL::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("REPL("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
@@ -706,6 +659,53 @@ return (has_error);
 }
 }
 
+ErrorOr<DeprecatedString> repl::Editor::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Editor("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("standard_input_file: {}, ", standard_input_file));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("line_pointer: {}, ", line_pointer));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("prompt: \"{}\"", prompt));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<repl::Editor> repl::Editor::create(DeprecatedString const prompt) {
+{
+FILE* std_in = fopen(((Jakt::DeprecatedString("/dev/stdin"sv)).characters()),((Jakt::DeprecatedString("r"sv)).characters()));
+if ((std_in == utility::null<FILE>())){
+warnln(Jakt::DeprecatedString("Could not open /dev/stdin for reading"sv));
+return Error::from_errno(static_cast<i32>(42));
+}
+repl::Editor const editor = repl::Editor(std_in,utility::allocate<char>(static_cast<size_t>(4096ULL)),prompt);
+return (editor);
+}
+}
+
+repl::Editor::Editor(FILE* a_standard_input_file, char* a_line_pointer, DeprecatedString a_prompt) :standard_input_file(move(a_standard_input_file)), line_pointer(move(a_line_pointer)), prompt(move(a_prompt)){}
+
+ErrorOr<repl::LineResult> repl::Editor::get_line() {
+{
+warn(Jakt::DeprecatedString("{}"sv),((*this).prompt));
+DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+{
+char* const c_string = fgets(((*this).line_pointer),static_cast<size_t>(4096ULL),((*this).standard_input_file));
+if ((c_string == utility::null<char>())){
+return ( repl::LineResult { typename repl::LineResult::Eof() } );
+}
+TRY((((builder).append_c_string(c_string))));
+}
+
+return ( repl::LineResult { typename repl::LineResult::Line(TRY((((builder).to_string())))) } );
+}
+}
+
+void repl::Editor::destroy() {
+{
+fclose(((*this).standard_input_file));
+{
+free(line_pointer);
+}
+
+}
+}
+
 ErrorOr<DeprecatedString> repl::LineResult::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
 switch (this->index()) {case 0 /* Line */: {
diff --git a/bootstrap/stage0/repl.h b/bootstrap/stage0/repl.h
index 9abe48445..a31f2774e 100644
--- a/bootstrap/stage0/repl.h
+++ b/bootstrap/stage0/repl.h
@@ -39,10 +39,10 @@ ErrorOr<DeprecatedString> debug_description() const;
 struct Editor {
   public:
 FILE* standard_input_file;char* line_pointer;DeprecatedString prompt;static ErrorOr<repl::Editor> create(DeprecatedString const prompt);
-void destroy();
 Editor(FILE* a_standard_input_file, char* a_line_pointer, DeprecatedString a_prompt);
 
 ErrorOr<repl::LineResult> get_line();
+void destroy();
 ErrorOr<DeprecatedString> debug_description() const;
 };}
 } // namespace Jakt
diff --git a/bootstrap/stage0/runtime/AK/GenericLexer.h b/bootstrap/stage0/runtime/AK/GenericLexer.h
index ee9a95e78..508c4df3a 100644
--- a/bootstrap/stage0/runtime/AK/GenericLexer.h
+++ b/bootstrap/stage0/runtime/AK/GenericLexer.h
@@ -22,6 +22,7 @@ class GenericLexer {
     constexpr size_t tell_remaining() const { return m_input.length() - m_index; }
 
     StringView remaining() const { return m_input.substring_view(m_index); }
+    StringView input() const { return m_input; }
 
     constexpr bool is_eof() const { return m_index >= m_input.length(); }
 
diff --git a/bootstrap/stage0/runtime/AK/HashFunctions.h b/bootstrap/stage0/runtime/AK/HashFunctions.h
index b36fd1d60..9994709af 100644
--- a/bootstrap/stage0/runtime/AK/HashFunctions.h
+++ b/bootstrap/stage0/runtime/AK/HashFunctions.h
@@ -19,20 +19,6 @@ constexpr unsigned int_hash(u32 key)
     return key;
 }
 
-constexpr unsigned rehash_for_collision(u32 key)
-{
-    unsigned const magic = 0xBA5EDB01;
-    if (key == magic)
-        return 0u;
-    if (key == 0u)
-        key = magic;
-
-    key ^= key << 13;
-    key ^= key >> 17;
-    key ^= key << 5;
-    return key;
-}
-
 constexpr unsigned pair_int_hash(u32 key1, u32 key2)
 {
     return int_hash((int_hash(key1) * 209) ^ (int_hash(key2 * 413)));
diff --git a/bootstrap/stage0/runtime/AK/HashTable.h b/bootstrap/stage0/runtime/AK/HashTable.h
index 4754e3da4..577dce859 100644
--- a/bootstrap/stage0/runtime/AK/HashTable.h
+++ b/bootstrap/stage0/runtime/AK/HashTable.h
@@ -1,5 +1,6 @@
 /*
  * Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
+ * Copyright (c) 2023, Jelle Raaijmakers <jelle@gmta.nl>
  *
  * SPDX-License-Identifier: BSD-2-Clause
  */
@@ -8,8 +9,6 @@
 
 #include <AK/Concepts.h>
 #include <AK/Error.h>
-#include <AK/Forward.h>
-#include <AK/HashFunctions.h>
 #include <AK/StdLibExtras.h>
 #include <AK/Traits.h>
 #include <AK/Types.h>
@@ -20,38 +19,23 @@ namespace AK {
 enum class HashSetResult {
     InsertedNewEntry,
     ReplacedExistingEntry,
-    KeptExistingEntry
+    KeptExistingEntry,
 };
 
 enum class HashSetExistingEntryBehavior {
     Keep,
-    Replace
+    Replace,
 };
 
-// Upper nibble determines state class:
-// - 0: unused bucket
-// - 1: used bucket
-// - F: end bucket
-// Lower nibble determines state within a class.
+// BucketState doubles as both an enum and a probe length value.
+// - Free: empty bucket
+// - Used (implicit, values 1..254): value-1 represents probe length
+// - CalculateLength: same as Used but probe length > 253, so we calculate the actual probe length
 enum class BucketState : u8 {
-    Free = 0x00,
-    Used = 0x10,
-    Deleted = 0x01,
-    Rehashed = 0x12,
-    End = 0xFF,
+    Free = 0,
+    CalculateLength = 255,
 };
 
-// Note that because there's the end state, used and free are not 100% opposites!
-constexpr bool is_used_bucket(BucketState state)
-{
-    return (static_cast<u8>(state) & 0xf0) == 0x10;
-}
-
-constexpr bool is_free_bucket(BucketState state)
-{
-    return (static_cast<u8>(state) & 0xf0) == 0x00;
-}
-
 template<typename HashTableType, typename T, typename BucketType>
 class HashTableIterator {
     friend HashTableType;
@@ -70,19 +54,21 @@ class HashTableIterator {
             return;
         do {
             ++m_bucket;
-            if (m_bucket->state == BucketState::Used)
+            if (m_bucket == m_end_bucket) {
+                m_bucket = nullptr;
                 return;
-        } while (m_bucket->state != BucketState::End);
-        if (m_bucket->state == BucketState::End)
-            m_bucket = nullptr;
+            }
+        } while (m_bucket->state == BucketState::Free);
     }
 
-    explicit HashTableIterator(BucketType* bucket)
+    HashTableIterator(BucketType* bucket, BucketType* end_bucket)
         : m_bucket(bucket)
+        , m_end_bucket(end_bucket)
     {
     }
 
     BucketType* m_bucket { nullptr };
+    BucketType* m_end_bucket { nullptr };
 };
 
 template<typename OrderedHashTableType, typename T, typename BucketType>
@@ -98,7 +84,7 @@ class OrderedHashTableIterator {
     void operator--() { m_bucket = m_bucket->previous; }
 
 private:
-    explicit OrderedHashTableIterator(BucketType* bucket)
+    OrderedHashTableIterator(BucketType* bucket, BucketType*)
         : m_bucket(bucket)
     {
     }
@@ -108,12 +94,13 @@ class OrderedHashTableIterator {
 
 template<typename T, typename TraitsForT, bool IsOrdered>
 class HashTable {
-    static constexpr size_t load_factor_in_percent = 60;
+    static constexpr size_t grow_capacity_at_least = 8;
+    static constexpr size_t grow_at_load_factor_percent = 80;
+    static constexpr size_t grow_capacity_increase_percent = 60;
 
     struct Bucket {
         BucketState state;
         alignas(T) u8 storage[sizeof(T)];
-
         T* slot() { return reinterpret_cast<T*>(storage); }
         T const* slot() const { return reinterpret_cast<T const*>(storage); }
     };
@@ -148,9 +135,11 @@ class HashTable {
         if (!m_buckets)
             return;
 
-        for (size_t i = 0; i < m_capacity; ++i) {
-            if (is_used_bucket(m_buckets[i].state))
-                m_buckets[i].slot()->~T();
+        if constexpr (!IsTriviallyDestructible<T>) {
+            for (size_t i = 0; i < m_capacity; ++i) {
+                if (m_buckets[i].state != BucketState::Free)
+                    m_buckets[i].slot()->~T();
+            }
         }
 
         kfree_sized(m_buckets, size_in_bytes(m_capacity));
@@ -175,11 +164,9 @@ class HashTable {
         , m_collection_data(other.m_collection_data)
         , m_size(other.m_size)
         , m_capacity(other.m_capacity)
-        , m_deleted_count(other.m_deleted_count)
     {
         other.m_size = 0;
         other.m_capacity = 0;
-        other.m_deleted_count = 0;
         other.m_buckets = nullptr;
         if constexpr (IsOrdered)
             other.m_collection_data = { nullptr, nullptr };
@@ -197,7 +184,6 @@ class HashTable {
         swap(a.m_buckets, b.m_buckets);
         swap(a.m_size, b.m_size);
         swap(a.m_capacity, b.m_capacity);
-        swap(a.m_deleted_count, b.m_deleted_count);
 
         if constexpr (IsOrdered)
             swap(a.m_collection_data, b.m_collection_data);
@@ -220,16 +206,20 @@ class HashTable {
         MUST(try_set_from(from_array));
     }
 
-    void ensure_capacity(size_t capacity)
+    ErrorOr<void> try_ensure_capacity(size_t capacity)
     {
-        VERIFY(capacity >= size());
-        rehash(capacity * 2);
+        // The user usually expects "capacity" to mean the number of values that can be stored in a
+        // container without it needing to reallocate. Our definition of "capacity" is the number of
+        // buckets we can store, but we reallocate earlier because of `grow_at_load_factor_percent`.
+        // This calculates the required internal capacity to store `capacity` number of values.
+        size_t required_capacity = capacity * 100 / grow_at_load_factor_percent + 1;
+        if (required_capacity <= m_capacity)
+            return {};
+        return try_rehash(required_capacity);
     }
-
-    ErrorOr<void> try_ensure_capacity(size_t capacity)
+    void ensure_capacity(size_t capacity)
     {
-        VERIFY(capacity >= size());
-        return try_rehash(capacity * 2);
+        MUST(try_ensure_capacity(capacity));
     }
 
     [[nodiscard]] bool contains(T const& value) const
@@ -250,18 +240,18 @@ class HashTable {
     [[nodiscard]] Iterator begin()
     {
         if constexpr (IsOrdered)
-            return Iterator(m_collection_data.head);
+            return Iterator(m_collection_data.head, end_bucket());
 
         for (size_t i = 0; i < m_capacity; ++i) {
-            if (is_used_bucket(m_buckets[i].state))
-                return Iterator(&m_buckets[i]);
+            if (m_buckets[i].state != BucketState::Free)
+                return Iterator(&m_buckets[i], end_bucket());
         }
         return end();
     }
 
     [[nodiscard]] Iterator end()
     {
-        return Iterator(nullptr);
+        return Iterator(nullptr, nullptr);
     }
 
     using ConstIterator = Conditional<IsOrdered,
@@ -271,24 +261,25 @@ class HashTable {
     [[nodiscard]] ConstIterator begin() const
     {
         if constexpr (IsOrdered)
-            return ConstIterator(m_collection_data.head);
+            return ConstIterator(m_collection_data.head, end_bucket());
 
         for (size_t i = 0; i < m_capacity; ++i) {
-            if (is_used_bucket(m_buckets[i].state))
-                return ConstIterator(&m_buckets[i]);
+            if (m_buckets[i].state != BucketState::Free)
+                return ConstIterator(&m_buckets[i], end_bucket());
         }
         return end();
     }
 
     [[nodiscard]] ConstIterator end() const
     {
-        return ConstIterator(nullptr);
+        return ConstIterator(nullptr, nullptr);
     }
 
     void clear()
     {
         *this = HashTable();
     }
+
     void clear_with_capacity()
     {
         if (m_capacity == 0)
@@ -297,44 +288,20 @@ class HashTable {
             for (auto* bucket : *this)
                 bucket->~T();
         }
-        __builtin_memset(m_buckets, 0, size_in_bytes(capacity()));
+        __builtin_memset(m_buckets, 0, size_in_bytes(m_capacity));
         m_size = 0;
-        m_deleted_count = 0;
 
         if constexpr (IsOrdered)
             m_collection_data = { nullptr, nullptr };
-        else
-            m_buckets[m_capacity].state = BucketState::End;
     }
 
     template<typename U = T>
     ErrorOr<HashSetResult> try_set(U&& value, HashSetExistingEntryBehavior existing_entry_behavior = HashSetExistingEntryBehavior::Replace)
     {
-        auto* bucket = TRY(try_lookup_for_writing(value));
-        if (is_used_bucket(bucket->state)) {
-            if (existing_entry_behavior == HashSetExistingEntryBehavior::Keep)
-                return HashSetResult::KeptExistingEntry;
-            (*bucket->slot()) = forward<U>(value);
-            return HashSetResult::ReplacedExistingEntry;
-        }
-
-        new (bucket->slot()) T(forward<U>(value));
-        if (bucket->state == BucketState::Deleted)
-            --m_deleted_count;
-        bucket->state = BucketState::Used;
-
-        if constexpr (IsOrdered) {
-            if (!m_collection_data.head) [[unlikely]] {
-                m_collection_data.head = bucket;
-            } else {
-                bucket->previous = m_collection_data.tail;
-                m_collection_data.tail->next = bucket;
-            }
-            m_collection_data.tail = bucket;
-        }
+        if (should_grow())
+            TRY(try_rehash(m_capacity * (100 + grow_capacity_increase_percent) / 100));
 
-        ++m_size;
-        return HashSetResult::InsertedNewEntry;
+        return write_value(forward<U>(value), existing_entry_behavior);
     }
     template<typename U = T>
     HashSetResult set(U&& value, HashSetExistingEntryBehavior existing_entry_behaviour = HashSetExistingEntryBehavior::Replace)
@@ -345,7 +312,7 @@ class HashTable {
     template<typename TUnaryPredicate>
     [[nodiscard]] Iterator find(unsigned hash, TUnaryPredicate predicate)
     {
-        return Iterator(lookup_with_hash(hash, move(predicate)));
+        return Iterator(lookup_with_hash(hash, move(predicate)), end_bucket());
     }
 
     [[nodiscard]] Iterator find(T const& value)
@@ -356,7 +323,7 @@ class HashTable {
     template<typename TUnaryPredicate>
     [[nodiscard]] ConstIterator find(unsigned hash, TUnaryPredicate predicate) const
     {
-        return ConstIterator(lookup_with_hash(hash, move(predicate)));
+        return ConstIterator(lookup_with_hash(hash, move(predicate)), end_bucket());
     }
 
     [[nodiscard]] ConstIterator find(T const& value) const
@@ -410,120 +377,89 @@ class HashTable {
         return false;
     }
 
-    void remove(Iterator iterator)
+    // This invalidates the iterator
+    void remove(Iterator& iterator)
     {
-        VERIFY(iterator.m_bucket);
-        auto& bucket = *iterator.m_bucket;
-        VERIFY(is_used_bucket(bucket.state));
-
-        delete_bucket(bucket);
-        --m_size;
-        ++m_deleted_count;
-
-        rehash_in_place_if_needed();
+        auto* bucket = iterator.m_bucket;
+        VERIFY(bucket);
+        delete_bucket(*bucket);
+        iterator.m_bucket = nullptr;
     }
 
     template<typename TUnaryPredicate>
     bool remove_all_matching(TUnaryPredicate const& predicate)
     {
-        size_t removed_count = 0;
+        bool has_removed_anything = false;
         for (size_t i = 0; i < m_capacity; ++i) {
             auto& bucket = m_buckets[i];
-            if (is_used_bucket(bucket.state) && predicate(*bucket.slot())) {
-                delete_bucket(bucket);
-                ++removed_count;
-            }
-        }
-        if (removed_count) {
-            m_deleted_count += removed_count;
-            m_size -= removed_count;
+            if (bucket.state == BucketState::Free || !predicate(*bucket.slot()))
+                continue;
+
+            delete_bucket(bucket);
+            has_removed_anything = true;
+
+            // If a bucket was shifted up, reevaluate this bucket index
+            if (bucket.state != BucketState::Free)
+                --i;
         }
-        rehash_in_place_if_needed();
-        return removed_count;
+        return has_removed_anything;
     }
 
     T pop()
+    requires(IsOrdered)
     {
         VERIFY(!is_empty());
-        T element;
-        if constexpr (IsOrdered) {
-            element = *m_collection_data.tail->slot();
-        } else {
-            for (size_t i = 0; i < m_capacity; ++i) {
-                if (is_used_bucket(m_buckets[i].state)) {
-                    element = *m_buckets[i].slot();
-                    break;
-                }
-            }
-        }
+        T element = *m_collection_data.tail->slot();
         remove(element);
         return element;
     }
 
 private:
-    void insert_during_rehash(T&& value)
-    {
-        auto& bucket = lookup_for_writing(value);
-        new (bucket.slot()) T(move(value));
-        bucket.state = BucketState::Used;
+    bool should_grow() const { return ((m_size + 1) * 100) >= (m_capacity * grow_at_load_factor_percent); }
+    static constexpr size_t size_in_bytes(size_t capacity) { return sizeof(BucketType) * capacity; }
 
-        if constexpr (IsOrdered) {
-            if (!m_collection_data.head) [[unlikely]] {
-                m_collection_data.head = &bucket;
-            } else {
-                bucket.previous = m_collection_data.tail;
-                m_collection_data.tail->next = &bucket;
-            }
-            m_collection_data.tail = &bucket;
-        }
+    BucketType* end_bucket()
+    {
+        if constexpr (IsOrdered)
+            return m_collection_data.tail;
+        else
+            return &m_buckets[m_capacity];
     }
-
-    [[nodiscard]] static constexpr size_t size_in_bytes(size_t capacity)
+    BucketType const* end_bucket() const
     {
-        if constexpr (IsOrdered) {
-            return sizeof(BucketType) * capacity;
-        } else {
-            return sizeof(BucketType) * (capacity + 1);
-        }
+        return const_cast<HashTable*>(this)->end_bucket();
     }
 
     ErrorOr<void> try_rehash(size_t new_capacity)
     {
-        if (new_capacity == m_capacity && new_capacity >= 4) {
-            rehash_in_place();
-            return {};
-        }
-
-        new_capacity = max(new_capacity, static_cast<size_t>(4));
-        new_capacity = kmalloc_good_size(new_capacity * sizeof(BucketType)) / sizeof(BucketType);
+        new_capacity = max(new_capacity, m_capacity + grow_capacity_at_least);
+        new_capacity = kmalloc_good_size(size_in_bytes(new_capacity)) / sizeof(BucketType);
+        VERIFY(new_capacity >= size());
 
         auto* old_buckets = m_buckets;
-        auto old_capacity = m_capacity;
+        auto old_buckets_size = size_in_bytes(m_capacity);
         Iterator old_iter = begin();
 
         auto* new_buckets = kcalloc(1, size_in_bytes(new_capacity));
         if (!new_buckets)
             return Error::from_errno(ENOMEM);
 
-        m_buckets = (BucketType*)new_buckets;
-
+        m_buckets = static_cast<BucketType*>(new_buckets);
         m_capacity = new_capacity;
-        m_deleted_count = 0;
 
         if constexpr (IsOrdered)
             m_collection_data = { nullptr, nullptr };
-        else
-            m_buckets[m_capacity].state = BucketState::End;
 
         if (!old_buckets)
             return {};
 
+        m_size = 0;
         for (auto it = move(old_iter); it != end(); ++it) {
-            insert_during_rehash(move(*it));
+            write_value(move(*it), HashSetExistingEntryBehavior::Keep);
             it->~T();
         }
 
-        kfree_sized(old_buckets, size_in_bytes(old_capacity));
+        kfree_sized(old_buckets, old_buckets_size);
         return {};
     }
     void rehash(size_t new_capacity)
@@ -531,194 +467,171 @@ class HashTable {
         MUST(try_rehash(new_capacity));
     }
 
-    void rehash_in_place()
+    template<typename TUnaryPredicate>
+    [[nodiscard]] BucketType* lookup_with_hash(unsigned hash, TUnaryPredicate predicate) const
     {
-        // FIXME: This implementation takes two loops over the entire bucket array, but avoids re-allocation.
-        //        Please benchmark your new implementation before you replace this.
-        //        The reason is that because of collisions, we use the special "rehashed" bucket state to mark already-rehashed used buckets.
-        //        Because we of course want to write into old used buckets, but already rehashed data shall not be touched.
-
-        // FIXME: Find a way to reduce the cognitive complexity of this function.
-
-        for (size_t i = 0; i < m_capacity; ++i) {
-            auto& bucket = m_buckets[i];
-
-            // FIXME: Bail out when we have handled every filled bucket.
-
-            if (bucket.state == BucketState::Rehashed || bucket.state == BucketState::End || bucket.state == BucketState::Free)
-                continue;
-            if (bucket.state == BucketState::Deleted) {
-                bucket.state = BucketState::Free;
-                continue;
-            }
-
-            auto const new_hash = TraitsForT::hash(*bucket.slot());
-            if (new_hash % m_capacity == i) {
-                bucket.state = BucketState::Rehashed;
-                continue;
-            }
+        if (is_empty())
+            return nullptr;
 
-            auto target_hash = new_hash;
-            auto const to_move_hash = i;
-            BucketType* target_bucket = &m_buckets[target_hash % m_capacity];
-            BucketType* bucket_to_move = &m_buckets[i];
+        hash %= m_capacity;
+        for (;;) {
+            auto* bucket = &m_buckets[hash];
+            if (bucket->state == BucketState::Free)
+                return nullptr;
+            if (predicate(*bucket->slot()))
+                return bucket;
+            if (++hash == m_capacity) [[unlikely]]
+                hash = 0;
+        }
+    }
 
-            // Try to move the bucket to move into its correct spot.
-            // During the procedure, we might re-hash or actually change the bucket to move.
-            while (!is_free_bucket(bucket_to_move->state)) {
+    size_t used_bucket_probe_length(BucketType const& bucket) const
+    {
+        VERIFY(bucket.state != BucketState::Free);
 
-                // If we're targeting ourselves, there's nothing to do.
-                if (to_move_hash == target_hash % m_capacity) {
-                    bucket_to_move->state = BucketState::Rehashed;
-                    break;
-                }
+        if (bucket.state == BucketState::CalculateLength) {
+            size_t ideal_bucket_index = TraitsForT::hash(*bucket.slot()) % m_capacity;
 
-                if (is_free_bucket(target_bucket->state)) {
-                    // We can just overwrite the target bucket and bail out.
-                    new (target_bucket->slot()) T(move(*bucket_to_move->slot()));
-                    target_bucket->state = BucketState::Rehashed;
-                    bucket_to_move->state = BucketState::Free;
-
-                    if constexpr (IsOrdered) {
-                        swap(bucket_to_move->previous, target_bucket->previous);
-                        swap(bucket_to_move->next, target_bucket->next);
-
-                        if (target_bucket->previous)
-                            target_bucket->previous->next = target_bucket;
-                        else
-                            m_collection_data.head = target_bucket;
-                        if (target_bucket->next)
-                            target_bucket->next->previous = target_bucket;
-                        else
-                            m_collection_data.tail = target_bucket;
-                    }
-                } else if (target_bucket->state == BucketState::Rehashed) {
-                    // If the target bucket is already re-hashed, we do normal probing.
-                    target_hash = rehash_for_collision(target_hash);
-                    target_bucket = &m_buckets[target_hash % m_capacity];
-                } else {
-                    VERIFY(target_bucket->state != BucketState::End);
-                    // The target bucket is a used bucket that hasn't been re-hashed.
-                    // Swap the data into the target; now the target's data resides in the bucket to move again.
-                    // (That's of course what we want, how neat!)
-                    swap(*bucket_to_move->slot(), *target_bucket->slot());
-                    bucket_to_move->state = target_bucket->state;
-                    target_bucket->state = BucketState::Rehashed;
-
-                    if constexpr (IsOrdered) {
-                        // Update state for the target bucket, we'll do the bucket to move later.
-                        swap(bucket_to_move->previous, target_bucket->previous);
-                        swap(bucket_to_move->next, target_bucket->next);
-
-                        if (target_bucket->previous)
-                            target_bucket->previous->next = target_bucket;
-                        else
-                            m_collection_data.head = target_bucket;
-                        if (target_bucket->next)
-                            target_bucket->next->previous = target_bucket;
-                        else
-                            m_collection_data.tail = target_bucket;
-                    }
+            VERIFY(&bucket >= m_buckets);
+            size_t actual_bucket_index = &bucket - m_buckets;
 
-                    target_hash = TraitsForT::hash(*bucket_to_move->slot());
-                    target_bucket = &m_buckets[target_hash % m_capacity];
-
-                    // The data is already in the correct location: Adjust the pointers
-                    if (target_hash % m_capacity == to_move_hash) {
-                        bucket_to_move->state = BucketState::Rehashed;
-                        if constexpr (IsOrdered) {
-                            // Update state for the bucket to move as it's not actually moved anymore.
-                            if (bucket_to_move->previous)
-                                bucket_to_move->previous->next = bucket_to_move;
-                            else
-                                m_collection_data.head = bucket_to_move;
-                            if (bucket_to_move->next)
-                                bucket_to_move->next->previous = bucket_to_move;
-                            else
-                                m_collection_data.tail = bucket_to_move;
-                        }
-                        break;
-                    }
-                }
-            }
-            // After this, the bucket_to_move either contains data that rehashes to itself, or it contains nothing as we were able to move the last thing.
-            if (bucket_to_move->state == BucketState::Deleted)
-                bucket_to_move->state = BucketState::Free;
-        }
-
-        for (size_t i = 0; i < m_capacity; ++i) {
-            if (m_buckets[i].state == BucketState::Rehashed)
-                m_buckets[i].state = BucketState::Used;
+            if (actual_bucket_index < ideal_bucket_index)
+                return m_capacity + actual_bucket_index - ideal_bucket_index;
+            return actual_bucket_index - ideal_bucket_index;
         }
 
-        m_deleted_count = 0;
+        return static_cast<u8>(bucket.state) - 1;
     }
 
-    void rehash_in_place_if_needed()
+    ALWAYS_INLINE constexpr BucketState bucket_state_for_probe_length(size_t probe_length)
     {
-        // This signals a "thrashed" hash table with many deleted slots.
-        if (m_deleted_count >= m_size && should_grow())
-            rehash_in_place();
+        if (probe_length > 253)
+            return BucketState::CalculateLength;
+        return static_cast<BucketState>(probe_length + 1);
     }
 
-    template<typename TUnaryPredicate>
-    [[nodiscard]] BucketType* lookup_with_hash(unsigned hash, TUnaryPredicate predicate) const
+    template<typename U = T>
+    HashSetResult write_value(U&& value, HashSetExistingEntryBehavior existing_entry_behavior)
     {
-        if (is_empty())
-            return nullptr;
-
-        for (;;) {
-            auto& bucket = m_buckets[hash % m_capacity];
-
-            if (is_used_bucket(bucket.state) && predicate(*bucket.slot()))
-                return &bucket;
-
-            if (bucket.state != BucketState::Used && bucket.state != BucketState::Deleted)
-                return nullptr;
+        auto update_collection_for_new_bucket = [&](BucketType& bucket) {
+            if constexpr (IsOrdered) {
+                if (!m_collection_data.head) [[unlikely]] {
+                    m_collection_data.head = &bucket;
+                } else {
+                    bucket.previous = m_collection_data.tail;
+                    m_collection_data.tail->next = &bucket;
+                }
+                m_collection_data.tail = &bucket;
+            }
+        };
+        auto update_collection_for_swapped_buckets = [&](BucketType* left_bucket, BucketType* right_bucket) {
+            if constexpr (IsOrdered) {
+                if (m_collection_data.head == left_bucket)
+                    m_collection_data.head = right_bucket;
+                else if (m_collection_data.head == right_bucket)
+                    m_collection_data.head = left_bucket;
+                if (m_collection_data.tail == left_bucket)
+                    m_collection_data.tail = right_bucket;
+                else if (m_collection_data.tail == right_bucket)
+                    m_collection_data.tail = left_bucket;
+
+                if (left_bucket->previous) {
+                    if (left_bucket->previous == left_bucket)
+                        left_bucket->previous = right_bucket;
+                    left_bucket->previous->next = left_bucket;
+                }
+                if (left_bucket->next) {
+                    if (left_bucket->next == left_bucket)
+                        left_bucket->next = right_bucket;
+                    left_bucket->next->previous = left_bucket;
+                }
 
-            hash = rehash_for_collision(hash);
-        }
-    }
+                if (right_bucket->previous && right_bucket->previous != left_bucket)
+                    right_bucket->previous->next = right_bucket;
+                if (right_bucket->next && right_bucket->next != left_bucket)
+                    right_bucket->next->previous = right_bucket;
+            }
+        };
 
-    ErrorOr<BucketType*> try_lookup_for_writing(T const& value)
-    {
-        // FIXME: Maybe overrun the "allowed" load factor to avoid OOM
-        //        If we are allowed to do that, separate that logic from
-        //        the normal lookup_for_writing
-        if (should_grow())
-            TRY(try_rehash(capacity() * 2));
-        auto hash = TraitsForT::hash(value);
-        BucketType* first_empty_bucket = nullptr;
+        auto bucket_index = TraitsForT::hash(value) % m_capacity;
+        size_t probe_length = 0;
         for (;;) {
-            auto& bucket = m_buckets[hash % m_capacity];
+            auto* bucket = &m_buckets[bucket_index];
+
+            // We found a free bucket, write to it and stop
+            if (bucket->state == BucketState::Free) {
+                new (bucket->slot()) T(forward<U>(value));
+                bucket->state = bucket_state_for_probe_length(probe_length);
+                update_collection_for_new_bucket(*bucket);
+                ++m_size;
+                return HashSetResult::InsertedNewEntry;
+            }
 
-            if (is_used_bucket(bucket.state) && TraitsForT::equals(*bucket.slot(), value))
-                return &bucket;
+            // The bucket is already used, does it have an identical value?
+            if (TraitsForT::equals(*bucket->slot(), static_cast<T const&>(value))) {
+                if (existing_entry_behavior == HashSetExistingEntryBehavior::Replace) {
+                    (*bucket->slot()) = forward<U>(value);
+                    return HashSetResult::ReplacedExistingEntry;
+                }
+                return HashSetResult::KeptExistingEntry;
+            }
+
+            // Robin hood: if our probe length is larger (poor) than this bucket's (rich), steal its position!
+            // This ensures that we will always traverse buckets in order of probe length.
+            auto target_probe_length = used_bucket_probe_length(*bucket);
+            if (probe_length > target_probe_length) {
+                // Copy out bucket
+                BucketType bucket_to_move = move(*bucket);
+                update_collection_for_swapped_buckets(bucket, &bucket_to_move);
+
+                // Write new bucket
+                new (bucket->slot()) T(forward<U>(value));
+                bucket->state = bucket_state_for_probe_length(probe_length);
+                probe_length = target_probe_length;
+                if constexpr (IsOrdered)
+                    bucket->next = nullptr;
+                update_collection_for_new_bucket(*bucket);
+                ++m_size;
+
+                // Find a free bucket, swapping with smaller probe length buckets along the way
+                for (;;) {
+                    if (++bucket_index == m_capacity) [[unlikely]]
+                        bucket_index = 0;
+                    bucket = &m_buckets[bucket_index];
+                    ++probe_length;
+
+                    if (bucket->state == BucketState::Free) {
+                        *bucket = move(bucket_to_move);
+                        bucket->state = bucket_state_for_probe_length(probe_length);
+                        update_collection_for_swapped_buckets(&bucket_to_move, bucket);
+                        break;
+                    }
 
-            if (!is_used_bucket(bucket.state)) {
-                if (!first_empty_bucket)
-                    first_empty_bucket = &bucket;
+                    target_probe_length = used_bucket_probe_length(*bucket);
+                    if (probe_length > target_probe_length) {
+                        swap(bucket_to_move, *bucket);
+                        bucket->state = bucket_state_for_probe_length(probe_length);
+                        probe_length = target_probe_length;
+                        update_collection_for_swapped_buckets(&bucket_to_move, bucket);
+                    }
+                }
 
-                if (bucket.state != BucketState::Deleted)
-                    return const_cast<BucketType*>(first_empty_bucket);
+                return HashSetResult::InsertedNewEntry;
             }
 
-            hash = rehash_for_collision(hash);
+            // Try next bucket
+            if (++bucket_index == m_capacity) [[unlikely]]
+                bucket_index = 0;
+            ++probe_length;
         }
     }
-    [[nodiscard]] BucketType& lookup_for_writing(T const& value)
-    {
-        return *MUST(try_lookup_for_writing(value));
-    }
-
-    [[nodiscard]] size_t used_bucket_count() const { return m_size + m_deleted_count; }
-    [[nodiscard]] bool should_grow() const { return ((used_bucket_count() + 1) * 100) >= (m_capacity * load_factor_in_percent); }
 
     void delete_bucket(auto& bucket)
     {
-        bucket.slot()->~T();
-        bucket.state = BucketState::Deleted;
+        VERIFY(bucket.state != BucketState::Free);
 
+        // Delete the bucket
+        bucket.slot()->~T();
         if constexpr (IsOrdered) {
             if (bucket.previous)
                 bucket.previous->next = bucket.next;
@@ -731,6 +644,48 @@ class HashTable {
             bucket.previous = nullptr;
             bucket.next = nullptr;
         }
+        --m_size;
+
+        // If we deleted a bucket, we need to make sure to shift up all buckets after it to ensure
+        // that we can still probe for buckets with collisions, and we automatically optimize the
+        // probe lengths. To do so, we shift the following buckets up until we reach a free bucket,
+        // or a bucket with a probe length of 0 (the ideal index for that bucket).
+        auto update_bucket_neighbours = [&](BucketType* bucket) {
+            if constexpr (IsOrdered) {
+                if (bucket->previous)
+                    bucket->previous->next = bucket;
+                if (bucket->next)
+                    bucket->next->previous = bucket;
+            }
+        };
+
+        VERIFY(&bucket >= m_buckets);
+        size_t shift_to_index = &bucket - m_buckets;
+        VERIFY(shift_to_index < m_capacity);
+        size_t shift_from_index = shift_to_index;
+        for (;;) {
+            if (++shift_from_index == m_capacity) [[unlikely]]
+                shift_from_index = 0;
+
+            auto* shift_from_bucket = &m_buckets[shift_from_index];
+            if (shift_from_bucket->state == BucketState::Free)
+                break;
+
+            auto shift_from_probe_length = used_bucket_probe_length(*shift_from_bucket);
+            if (shift_from_probe_length == 0)
+                break;
+
+            auto* shift_to_bucket = &m_buckets[shift_to_index];
+            *shift_to_bucket = move(*shift_from_bucket);
+            shift_to_bucket->state = bucket_state_for_probe_length(shift_from_probe_length - 1);
+            update_bucket_neighbours(shift_to_bucket);
+
+            if (++shift_to_index == m_capacity) [[unlikely]]
+                shift_to_index = 0;
+        }
+
+        // Mark last bucket as free
+        m_buckets[shift_to_index].state = BucketState::Free;
     }
 
     BucketType* m_buckets { nullptr };
@@ -738,7 +693,6 @@ class HashTable {
     [[no_unique_address]] CollectionDataType m_collection_data;
     size_t m_size { 0 };
     size_t m_capacity { 0 };
-    size_t m_deleted_count { 0 };
 };
 }
 
diff --git a/bootstrap/stage0/runtime/AK/SIMDMath.h b/bootstrap/stage0/runtime/AK/SIMDMath.h
index ca0708858..5356d184c 100644
--- a/bootstrap/stage0/runtime/AK/SIMDMath.h
+++ b/bootstrap/stage0/runtime/AK/SIMDMath.h
@@ -66,6 +66,15 @@ ALWAYS_INLINE static f32x4 exp(f32x4 v)
     };
 }
 
+ALWAYS_INLINE static f32x4 exp_approximate(f32x4 v)
+{
+    static constexpr int number_of_iterations = 10;
+    auto result = 1.f + v / (1 << number_of_iterations);
+    for (int i = 0; i < number_of_iterations; ++i)
+        result *= result;
+    return result;
+}
+
 ALWAYS_INLINE static f32x4 sqrt(f32x4 v)
 {
 #if ARCH(x86_64)
diff --git a/bootstrap/stage0/runtime/AK/String.cpp b/bootstrap/stage0/runtime/AK/String.cpp
index 49aed1d24..d1dc6d2e9 100644
--- a/bootstrap/stage0/runtime/AK/String.cpp
+++ b/bootstrap/stage0/runtime/AK/String.cpp
@@ -77,7 +77,7 @@ class StringData final : public RefCounted<StringData> {
     bool m_substring { false };
     bool m_is_fly_string { false };
 
-    u8 m_bytes_or_substring_data[0];
+    alignas(SubstringData) u8 m_bytes_or_substring_data[0];
 };
 
 void StringData::operator delete(void* ptr)
diff --git a/bootstrap/stage0/runtime/AK/StringImpl.cpp b/bootstrap/stage0/runtime/AK/StringImpl.cpp
index 56f2cc73d..414383502 100644
--- a/bootstrap/stage0/runtime/AK/StringImpl.cpp
+++ b/bootstrap/stage0/runtime/AK/StringImpl.cpp
@@ -6,7 +6,6 @@
 
 #include <AK/CharacterTypes.h>
 #include <AK/DeprecatedFlyString.h>
-#include <AK/HashTable.h>
 #include <AK/StringHash.h>
 #include <AK/StringImpl.h>
 #include <AK/kmalloc.h>
diff --git a/bootstrap/stage0/typechecker.cpp b/bootstrap/stage0/typechecker.cpp
index c2a86a784..48a6a15be 100644
--- a/bootstrap/stage0/typechecker.cpp
+++ b/bootstrap/stage0/typechecker.cpp
@@ -10,182 +10,133 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(builder.append(")"sv));return builder.to_string(); }
 typechecker::TraitImplementationDescriptor::TraitImplementationDescriptor(types::TraitId a_trait_id, DeprecatedString a_trait_name, JaktInternal::DynamicArray<types::TypeId> a_implemented_type_args) :trait_id(move(a_trait_id)), trait_name(move(a_trait_name)), implemented_type_args(move(a_implemented_type_args)){}
 
-ErrorOr<DeprecatedString> typechecker::AlreadyImplementedFor::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("AlreadyImplementedFor("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("trait_name: \"{}\", ", trait_name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("encounter_span: {}", encounter_span));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-typechecker::AlreadyImplementedFor::AlreadyImplementedFor(DeprecatedString a_trait_name, utility::Span a_encounter_span) :trait_name(move(a_trait_name)), encounter_span(move(a_encounter_span)){}
-
-ErrorOr<DeprecatedString> typechecker::ImportRestrictions::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ImportRestrictions("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("functions: {}, ", functions));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("structs: {}, ", structs));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("enums: {}, ", enums));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("types: {}, ", types));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespaces: {}", namespaces));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-typechecker::ImportRestrictions::ImportRestrictions(bool a_functions, bool a_structs, bool a_enums, bool a_types, bool a_traits, bool a_namespaces) :functions(move(a_functions)), structs(move(a_structs)), enums(move(a_enums)), types(move(a_types)), traits(move(a_traits)), namespaces(move(a_namespaces)){}
-
-typechecker::ImportRestrictions typechecker::ImportRestrictions::all() {
-{
-return (typechecker::ImportRestrictions(true,true,true,true,true,true));
-}
-}
-
-ErrorOr<DeprecatedString> typechecker::Typechecker::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Typechecker("sv));{
+ErrorOr<DeprecatedString> typechecker::TraitImplCheck::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("TraitImplCheck("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("program: {}, ", *program));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("current_module_id: {}, ", current_module_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("current_struct_type_id: {}, ", current_struct_type_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("current_function_id: {}, ", current_function_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("inside_defer: {}, ", inside_defer));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("checkidx: {}, ", checkidx));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("ignore_errors: {}, ", ignore_errors));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("dump_type_hints: {}, ", dump_type_hints));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("dump_try_hints: {}, ", dump_try_hints));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("lambda_count: {}, ", lambda_count));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_inferences: {}, ", generic_inferences));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("self_type_id: {}, ", self_type_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("root_module_name: \"{}\", ", root_module_name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("in_comptime_function_call: {}, ", in_comptime_function_call));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("had_an_error: {}", had_an_error));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("missing_methods: {}, ", missing_methods));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("unmatched_signatures: {}, ", unmatched_signatures));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("private_matching_methods: {}, ", private_matching_methods));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("already_implemented_for: {}", already_implemented_for));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<void> typechecker::Typechecker::typecheck_namespace_predecl(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
+ErrorOr<void> typechecker::TraitImplCheck::throw_errors(utility::Span const record_decl_span,typechecker::Typechecker& typechecker) {
 {
-size_t const module_struct_len = ((((((*this).current_module()))->structures)).size());
-size_t const module_enum_len = ((((((*this).current_module()))->enums)).size());
-size_t struct_index = static_cast<size_t>(0ULL);
-size_t enum_index = static_cast<size_t>(0ULL);
 {
-JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> _magic = ((((*this).missing_methods)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedRecord parsed_record = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> trait_name__missing_methods__ = (_magic_value.value());
 {
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((parsed_record).record_type);
-switch(__jakt_match_variant.index()) {
-case 0: {
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> const jakt__trait_name__missing_methods__ = trait_name__missing_methods__;
+DeprecatedString const trait_name = ((jakt__trait_name__missing_methods__).template get<0>());
+JaktInternal::Dictionary<DeprecatedString,types::FunctionId> const missing_methods = ((jakt__trait_name__missing_methods__).template get<1>());
+
+JaktInternal::Dictionary<DeprecatedString,utility::Span> const unmatched_signatures = ((((*this).unmatched_signatures))[trait_name]);
+JaktInternal::Dictionary<DeprecatedString,utility::Span> const private_matching_methods = ((((*this).private_matching_methods))[trait_name]);
 {
-TRY((((*this).typecheck_struct_predecl_initial(parsed_record,((struct_index++)),module_struct_len,scope_id))));
+JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((missing_methods).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> method_name__trait_method_id__ = (_magic_value.value());
 {
-TRY((((*this).typecheck_struct_predecl_initial(parsed_record,((struct_index++)),module_struct_len,scope_id))));
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__method_name__trait_method_id__ = method_name__trait_method_id__;
+DeprecatedString const method_name = ((jakt__method_name__trait_method_id__).template get<0>());
+types::FunctionId const trait_method_id = ((jakt__method_name__trait_method_id__).template get<1>());
+
+JaktInternal::Optional<typechecker::AlreadyImplementedFor> const already_implemented_for = ((((*this).already_implemented_for)).get(method_name));
+JaktInternal::Optional<utility::Span> const unmatched_signature = ((unmatched_signatures).get(method_name));
+JaktInternal::Optional<utility::Span> const private_matching_method = ((private_matching_methods).get(method_name));
+if (((already_implemented_for).has_value())){
+TRY((((((typechecker))).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot implement ‘{}’ for ‘{}’ because it's already implementing ‘{}’"sv),method_name,trait_name,(((already_implemented_for.value())).trait_name)))),(((already_implemented_for.value())).encounter_span)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-{
-TRY((((*this).typecheck_enum_predecl_initial(parsed_record,((enum_index++)),module_enum_len,scope_id))));
+else if (((private_matching_method).has_value())){
+utility::Span const span = (private_matching_method.value());
+TRY((((((typechecker))).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Implementation of ‘{}’ for trait ‘{}’ is valid but is not public"sv),method_name,trait_name))),span,Jakt::DeprecatedString("Consider adding ‘public’ to make the method accessible"sv),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-{
-TRY((((*this).typecheck_enum_predecl_initial(parsed_record,((enum_index++)),module_enum_len,scope_id))));
+else {
+NonnullRefPtr<types::CheckedFunction> const func = ((((typechecker))).get_function(trait_method_id));
+if ((!(((((((func)->block)).statements)).is_empty())))){
+continue;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 4: {
-{
+if (((unmatched_signature).has_value())){
+utility::Span const method_span = (unmatched_signature.value());
+TRY((((((typechecker))).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Missing implementation for method ‘{}’ of trait ‘{}’"sv),method_name,trait_name))),record_decl_span,Jakt::DeprecatedString("The method is declared here, but its signature doesn't match"sv),method_span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
+else {
+utility::Span const trait_method_span = ((((((typechecker))).get_function(trait_method_id)))->name_span);
+TRY((((((typechecker))).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Missing implementation for method ‘{}’ of trait ‘{}’"sv),method_name,trait_name))),record_decl_span,Jakt::DeprecatedString("Consider implementing the method with the signature specified here"sv),trait_method_span))));
 }
 
 }
+
 }
 
-{
-JaktInternal::ArrayIterator<parser::ParsedNamespace> _magic = ((((parsed_namespace).namespaces)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedNamespace> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedNamespace namespace_ = (_magic_value.value());
-{
-DeprecatedString debug_name = Jakt::DeprecatedString("namespace("sv);
-if (((((namespace_).name)).has_value())){
-(debug_name += (((namespace_).name).value()));
 }
-else {
-(debug_name += Jakt::DeprecatedString("unnamed-namespace"sv));
+
 }
 
-(debug_name += Jakt::DeprecatedString(")"sv));
-types::ScopeId const parent_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId,ErrorOr<void>>{
-auto __jakt_enum_value = (((((namespace_).import_path_if_extern)).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(types::ScopeId(types::ModuleId(static_cast<size_t>(1ULL)),static_cast<size_t>(0ULL)));
 }
-else {
-return JaktInternal::ExplicitValue(scope_id);
 }
-}()))
-;
-types::ScopeId const namespace_scope_id = TRY((((*this).create_scope(parent_scope_id,false,debug_name,false))));
-NonnullRefPtr<types::Scope> child_scope = TRY((((*this).get_scope(namespace_scope_id))));
-(((child_scope)->namespace_name) = ((namespace_).name));
-(((child_scope)->import_path_if_extern) = ((namespace_).import_path_if_extern));
-(((child_scope)->before_extern_include) = ((namespace_).generating_import_extern_before_include));
-(((child_scope)->after_extern_include) = ((namespace_).generating_import_extern_after_include));
-if (((((namespace_).import_path_if_extern)).has_value())){
-TRY((((((child_scope)->resolution_mixins)).push(scope_id))));
+
 }
-NonnullRefPtr<types::Scope> parent_scope = TRY((((*this).get_scope(scope_id))));
-TRY((((((parent_scope)->children)).push(namespace_scope_id))));
-TRY((((*this).typecheck_namespace_predecl(namespace_,namespace_scope_id))));
+return {};
 }
 
+ErrorOr<void> typechecker::TraitImplCheck::ensure_capacity(size_t const count) {
+{
+TRY((((((*this).missing_methods)).ensure_capacity(count))));
+TRY((((((*this).unmatched_signatures)).ensure_capacity(count))));
+TRY((((((*this).private_matching_methods)).ensure_capacity(count))));
+TRY((((((*this).already_implemented_for)).ensure_capacity(count))));
 }
+return {};
 }
 
+ErrorOr<void> typechecker::TraitImplCheck::register_method(types::TypeId const self_type_id,DeprecatedString const method_name,types::FunctionId const method_id,typechecker::Typechecker& typechecker) {
 {
-JaktInternal::ArrayIterator<parser::ParsedTrait> _magic = ((((parsed_namespace).traits)).iterator());
+NonnullRefPtr<types::CheckedFunction> const method = ((((typechecker))).get_function(method_id));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> _magic = ((((*this).missing_methods)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedTrait> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedTrait parsed_trait = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> trait_name__methods__ = (_magic_value.value());
 {
-TRY((((*this).typecheck_trait_predecl(parsed_trait,scope_id))));
-}
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> const jakt__trait_name__methods__ = trait_name__methods__;
+DeprecatedString const trait_name = ((jakt__trait_name__methods__).template get<0>());
+JaktInternal::Dictionary<DeprecatedString,types::FunctionId> const methods = ((jakt__trait_name__methods__).template get<1>());
 
+JaktInternal::Optional<types::FunctionId> const trait_method_id = ((methods).get(method_name));
+if (((trait_method_id).has_value())){
+NonnullRefPtr<types::CheckedFunction> const trait_method = ((((typechecker))).get_function((trait_method_id.value())));
+if (TRY((((((typechecker))).signatures_match(self_type_id,trait_method,method))))){
+if (((((method)->visibility)).index() == 0 /* Public */)){
+((((((*this).missing_methods))[trait_name])).remove(method_name));
+TRY(((*this).already_implemented_for).set(method_name, typechecker::AlreadyImplementedFor(trait_name,((method)->name_span))));
+break;
 }
+else {
+TRY((((((((*this).private_matching_methods))[trait_name])).set(method_name,((method)->name_span)))));
+continue;
 }
 
-{
-JaktInternal::ArrayIterator<parser::ParsedTrait> _magic = ((((parsed_namespace).traits)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedTrait> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedTrait parsed_trait = (_magic_value.value());
-{
-JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((parsed_trait).name)))));
-if (((trait_id).has_value())){
-TRY((((*this).typecheck_trait(parsed_trait,(trait_id.value()),scope_id))));
+else {
+TRY((((((((*this).unmatched_signatures))[trait_name])).set(method_name,((method)->name_span)))));
+continue;
+}
+
 }
 else {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find trait that has been previous added"sv)))));
+continue;
 }
 
 }
@@ -193,263 +144,313 @@ TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find trait that
 }
 }
 
-(struct_index = static_cast<size_t>(0ULL));
-(enum_index = static_cast<size_t>(0ULL));
+}
+return {};
+}
+
+ErrorOr<typechecker::TraitImplCheck> typechecker::TraitImplCheck::make() {
 {
-JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+return (typechecker::TraitImplCheck((TRY((Dictionary<DeprecatedString, JaktInternal::Dictionary<DeprecatedString,types::FunctionId>>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, JaktInternal::Dictionary<DeprecatedString,utility::Span>>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, JaktInternal::Dictionary<DeprecatedString,utility::Span>>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, typechecker::AlreadyImplementedFor>::create_with_entries({}))))));
+}
+}
+
+typechecker::TraitImplCheck::TraitImplCheck(JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> a_missing_methods, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> a_unmatched_signatures, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> a_private_matching_methods, JaktInternal::Dictionary<DeprecatedString,typechecker::AlreadyImplementedFor> a_already_implemented_for) :missing_methods(move(a_missing_methods)), unmatched_signatures(move(a_unmatched_signatures)), private_matching_methods(move(a_private_matching_methods)), already_implemented_for(move(a_already_implemented_for)){}
+
+ErrorOr<void> typechecker::TraitImplCheck::register_trait(types::TraitId const trait_id,DeprecatedString const trait_name,JaktInternal::Dictionary<DeprecatedString,types::FunctionId> const trait_methods) {
+{
+TRY(((*this).unmatched_signatures).set(trait_name, (TRY((Dictionary<DeprecatedString, utility::Span>::create_with_entries({}))))));
+TRY(((*this).private_matching_methods).set(trait_name, (TRY((Dictionary<DeprecatedString, utility::Span>::create_with_entries({}))))));
+JaktInternal::Dictionary<DeprecatedString,types::FunctionId> missing_methods = (TRY((Dictionary<DeprecatedString, types::FunctionId>::create_with_entries({}))));
+TRY((((missing_methods).ensure_capacity(((trait_methods).size())))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((trait_methods).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedRecord parsed_record = (_magic_value.value());
-{
-types::StructId const struct_id = types::StructId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(struct_index,module_struct_len)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((parsed_record).record_type);
-switch(__jakt_match_variant.index()) {
-case 0: {
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> method_name__method_id__ = (_magic_value.value());
 {
-TRY((((*this).typecheck_struct_predecl(parsed_record,struct_id,scope_id))));
-((struct_index++));
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__method_name__method_id__ = method_name__method_id__;
+DeprecatedString const method_name = ((jakt__method_name__method_id__).template get<0>());
+types::FunctionId const method_id = ((jakt__method_name__method_id__).template get<1>());
+
+TRY((((missing_methods).set(method_name,method_id))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-{
-TRY((((*this).typecheck_struct_predecl(parsed_record,struct_id,scope_id))));
-((struct_index++));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-{
-types::EnumId const enum_id = types::EnumId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(enum_index,module_enum_len)));
-TRY((((*this).typecheck_enum_predecl(parsed_record,enum_id,scope_id))));
-((enum_index++));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-{
-types::EnumId const enum_id = types::EnumId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(enum_index,module_enum_len)));
-TRY((((*this).typecheck_enum_predecl(parsed_record,enum_id,scope_id))));
-((enum_index++));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 4: {
-{
+
+TRY((((((*this).missing_methods)).set(trait_name,missing_methods))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
+return {};
 }
 
+ErrorOr<DeprecatedString> typechecker::AlreadyImplementedFor::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("AlreadyImplementedFor("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("trait_name: \"{}\", ", trait_name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("encounter_span: {}", encounter_span));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+typechecker::AlreadyImplementedFor::AlreadyImplementedFor(DeprecatedString a_trait_name, utility::Span a_encounter_span) :trait_name(move(a_trait_name)), encounter_span(move(a_encounter_span)){}
+
+ErrorOr<DeprecatedString> typechecker::ImportRestrictions::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ImportRestrictions("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("functions: {}, ", functions));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("structs: {}, ", structs));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("enums: {}, ", enums));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("types: {}, ", types));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespaces: {}", namespaces));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+typechecker::ImportRestrictions::ImportRestrictions(bool a_functions, bool a_structs, bool a_enums, bool a_types, bool a_traits, bool a_namespaces) :functions(move(a_functions)), structs(move(a_structs)), enums(move(a_enums)), types(move(a_types)), traits(move(a_traits)), namespaces(move(a_namespaces)){}
 
+typechecker::ImportRestrictions typechecker::ImportRestrictions::all() {
 {
-JaktInternal::ArrayIterator<parser::ParsedExternalTraitImplementation> _magic = ((((parsed_namespace).external_trait_implementations)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedExternalTraitImplementation> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (typechecker::ImportRestrictions(true,true,true,true,true,true));
 }
-parser::ParsedExternalTraitImplementation implementation = (_magic_value.value());
-{
-types::TypeId const for_type = TRY((((*this).typecheck_typename(((implementation).for_type),scope_id,JaktInternal::OptionalNone()))));
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = for_type);
-ScopeGuard __jakt_var_413([&] {
-{
-(((*this).self_type_id) = old_self_type_id);
 }
 
-});
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((*this).get_type(for_type));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-{
-types::CheckedStruct struct_ = ((*this).get_struct(struct_id));
+ErrorOr<DeprecatedString> typechecker::Typechecker::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Typechecker("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("program: {}, ", *program));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("current_module_id: {}, ", current_module_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("current_struct_type_id: {}, ", current_struct_type_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("current_function_id: {}, ", current_function_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("inside_defer: {}, ", inside_defer));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("checkidx: {}, ", checkidx));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("ignore_errors: {}, ", ignore_errors));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("dump_type_hints: {}, ", dump_type_hints));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("dump_try_hints: {}, ", dump_try_hints));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("lambda_count: {}, ", lambda_count));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_inferences: {}, ", generic_inferences));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("self_type_id: {}, ", self_type_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("root_module_name: \"{}\", ", root_module_name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("in_comptime_function_call: {}, ", in_comptime_function_call));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("had_an_error: {}", had_an_error));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<void> typechecker::Typechecker::typecheck_struct_predecl_initial(parser::ParsedRecord const parsed_record,size_t const struct_index,size_t const module_struct_len,types::ScopeId const scope_id) {
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+types::ModuleId const module_id = ((*this).current_module_id);
+types::StructId const struct_id = types::StructId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(struct_index,module_struct_len)));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
+types::TypeId const struct_type_id = types::TypeId(module_id,(JaktInternal::checked_sub<size_t>(((((((*this).current_module()))->types)).size()),static_cast<size_t>(1ULL))));
+TRY((((*this).add_type_to_scope(scope_id,((parsed_record).name),struct_type_id,((parsed_record).name_span)))));
+types::ScopeId const struct_scope_id = TRY((((*this).create_scope(scope_id,false,TRY((__jakt_format(Jakt::DeprecatedString("struct({})"sv),((parsed_record).name)))),false))));
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(struct_scope_id))));
+(((scope)->namespace_name) = ((parsed_record).name));
+(((scope)->external_name) = ((parsed_record).external_name));
+TRY((((((module)->structures)).push(types::CheckedStruct(((parsed_record).name),((parsed_record).name_span),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),(TRY((DynamicArray<types::CheckedField>::create_with({})))),struct_scope_id,((parsed_record).definition_linkage),(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))),((parsed_record).record_type),struct_type_id,JaktInternal::OptionalNone(),((parsed_record).external_name))))));
 }
-parser::ParsedMethod method = (_magic_value.value());
+return {};
+}
+
+ErrorOr<JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>>> typechecker::Typechecker::typecheck_match_body(parser::ParsedMatchBody const body,types::ScopeId const scope_id,types::SafetyMode const safety_mode,types::GenericInferences& generic_inferences,JaktInternal::Optional<types::TypeId> const final_result_type,utility::Span const span) {
 {
-JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
-if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
-(this_arg_type_id = for_type);
+JaktInternal::Optional<types::TypeId> result_type = final_result_type;
+types::CheckedMatchBody const checked_match_body = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedMatchBody, ErrorOr<JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>>>>{
+auto&& __jakt_match_variant = body;
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchBody::Block>();
+parser::ParsedBlock const& block = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::CheckedMatchBody> __jakt_var_413; {
+types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(block,scope_id,safety_mode,final_result_type))));
+if ((((((checked_block).control_flow)).may_return()) || ((((checked_block).yielded_type)).has_value()))){
+types::TypeId const block_type_id = ((checked_block).yielded_type).value_or_lazy_evaluated([&] { return types::void_type_id(); });
+utility::Span const yield_span = ((block).find_yield_span()).value_or_lazy_evaluated([&] { return span; });
+if (((result_type).has_value())){
+TRY((((*this).check_types_for_compat((result_type.value()),block_type_id,generic_inferences,yield_span))));
 }
-TRY((((*this).typecheck_function_predecl(((method).parsed_function),((struct_).scope_id),this_arg_type_id,JaktInternal::OptionalNone()))));
+else {
+(result_type = block_type_id);
 }
 
 }
+JaktInternal::Optional<types::CheckedMatchBody> final_body = JaktInternal::OptionalNone();
+if ((((((checked_block).yielded_type)).has_value()) && (!(((((checked_block).control_flow)).never_returns()))))){
+(final_body =  types::CheckedMatchBody { typename types::CheckedMatchBody::Expression(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Block>(checked_block,span,(((checked_block).yielded_type).value()))))) } );
+}
+else {
+(final_body =  types::CheckedMatchBody { typename types::CheckedMatchBody::Block(checked_block) } );
 }
 
-TRY((((*this).fill_trait_implementation_list(((implementation).traits),((((struct_).trait_implementations))),((struct_).scope_id),scope_id))));
-{
-JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((((implementation).traits)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+__jakt_var_413 = (final_body.value()); goto __jakt_label_393;
+
 }
-parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
-{
-JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((trait_name).name)))));
-if (((trait_id).has_value())){
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait((trait_id.value())));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+__jakt_label_393:; __jakt_var_413.release_value(); }));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchBody::Expression>();
+NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::CheckedMatchBody> __jakt_var_414; {
+NonnullRefPtr<typename types::CheckedExpression> const checked_expression = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,result_type))));
+if (((result_type).has_value())){
+TRY((((*this).check_types_for_compat((result_type.value()),((checked_expression)->type()),generic_inferences,span))));
+}
+else {
+(result_type = ((checked_expression)->type()));
 }
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
-DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
-types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
 
-if (((TRY((((*this).find_functions_with_name_in_scope(((struct_).scope_id),name))))).has_value())){
-continue;
+__jakt_var_414 =  types::CheckedMatchBody { typename types::CheckedMatchBody::Expression(checked_expression) } ; goto __jakt_label_394;
+
 }
-NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
-if (((((((function)->block)).statements)).is_empty())){
-continue;
+__jakt_label_394:; __jakt_var_414.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+return ((Tuple{checked_match_body, result_type}));
 }
-NonnullRefPtr<types::CheckedFunction> replaced_function = TRY((((function)->copy())));
-types::GenericInferences const inferences = ((*this).generic_inferences);
-TRY((((replaced_function)->map_types((([inferences](types::TypeId type_id) -> ErrorOr<types::TypeId> {
+}
+
+ErrorOr<DeprecatedString> typechecker::Typechecker::type_name(types::TypeId const type_id,bool const debug_mode) const {
 {
-return (TRY((((inferences).map(type_id)))));
+types::TypeId id = type_id;
+if ((((((((*this).program))->get_type(id)))->index() == 30 /* Self */) && ((((*this).self_type_id)).has_value()))){
+(id = (((*this).self_type_id).value()));
 }
+return (TRY((((((*this).program))->type_name(id,debug_mode)))));
 }
-))))));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::FunctionId const new_function_id = TRY((((module)->add_function(replaced_function))));
-TRY((((*this).add_function_to_scope(((struct_).scope_id),name,(TRY((DynamicArray<types::FunctionId>::create_with({new_function_id})))),((trait_name).name_span)))));
 }
 
+ErrorOr<types::ScopeId> typechecker::Typechecker::create_scope(JaktInternal::Optional<types::ScopeId> const parent_scope_id,bool const can_throw,DeprecatedString const debug_name,bool const for_block) {
+{
+return (TRY((((((*this).program))->create_scope(parent_scope_id,can_throw,debug_name,((*this).current_module_id),for_block)))));
 }
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_return(JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const expr,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode) {
+{
+if (((*this).inside_defer)){
+TRY((((*this).error(Jakt::DeprecatedString("‘return’ is not allowed inside ‘defer’"sv),span))));
 }
-else {
-continue;
+if ((!(((expr).has_value())))){
+if (((((*this).current_function_id)).has_value())){
+NonnullRefPtr<types::CheckedFunction> const current_function = ((*this).get_function((((*this).current_function_id).value())));
+NonnullRefPtr<typename types::Type> const return_type = ((*this).get_type(((current_function)->return_type_id)));
+if (((!(((return_type)->index() == 0 /* Void */))) && (!(((return_type)->index() == 16 /* Unknown */))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("’return’ with no value in function ’{}’ returning ’{}’"sv),((current_function)->name),TRY((((*this).type_name(((current_function)->return_type_id),false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("Add return value of type ’{}’ here"sv),TRY((((*this).type_name(((current_function)->return_type_id),false))))))),span))));
 }
-
 }
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Return>(JaktInternal::OptionalNone(),span))));
+}
+if (((!((((((*this).current_function_id)).has_value()) && ((((*this).get_function((((*this).current_function_id).value()))))->is_comptime)))) && (((expr.value()))->index() == 25 /* Function */))){
+TRY((((*this).error(Jakt::DeprecatedString("Returning a function is not currently supported"sv),span))));
+}
+JaktInternal::Optional<types::TypeId> type_hint = JaktInternal::OptionalNone();
+if (((((*this).current_function_id)).has_value())){
+(type_hint = static_cast<JaktInternal::Optional<types::TypeId>>(((((*this).get_function((((*this).current_function_id).value()))))->return_type_id)));
+}
+JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const new_condition_new_then_block_new_else_statement_ = TRY((((*this).expand_context_for_bindings((expr.value()),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),span))));
+NonnullRefPtr<typename parser::ParsedExpression> const new_condition = ((new_condition_new_then_block_new_else_statement_).template get<0>());
+JaktInternal::Optional<parser::ParsedBlock> const new_then_block = ((new_condition_new_then_block_new_else_statement_).template get<1>());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const new_else_statement = ((new_condition_new_then_block_new_else_statement_).template get<2>());
 
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(new_condition,scope_id,safety_mode,type_hint,span))));
+if (((type_hint).has_value())){
+TRY((((*this).unify_with_type(((checked_expr)->type()),(type_hint.value()),span))));
+}
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Return>(checked_expr,span))));
 }
 }
 
+NonnullRefPtr<types::CheckedTrait> typechecker::Typechecker::get_trait(types::TraitId const id) const {
+{
+return (((((*this).program))->get_trait(id)));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
+}
+
+ErrorOr<void> typechecker::Typechecker::typecheck_namespace_function_predecl(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
 {
-types::CheckedStruct struct_ = ((*this).get_struct(struct_id));
+JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
 for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMethod method = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
-if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
-(this_arg_type_id = for_type);
-}
-TRY((((*this).typecheck_function_predecl(((method).parsed_function),((struct_).scope_id),this_arg_type_id,JaktInternal::OptionalNone()))));
+parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
+types::ScopeId const child_namespace_scope_id = ((children)[i]);
+TRY((((*this).typecheck_namespace_function_predecl(child_namespace,child_namespace_scope_id))));
 }
 
 }
 }
 
-TRY((((*this).fill_trait_implementation_list(((implementation).traits),((((struct_).trait_implementations))),((struct_).scope_id),scope_id))));
 {
-JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((((implementation).traits)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((parsed_namespace).functions)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
-{
-JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((trait_name).name)))));
-if (((trait_id).has_value())){
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait((trait_id.value())));
+parser::ParsedFunction fun = (_magic_value.value());
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).typecheck_function_predecl(fun,scope_id,JaktInternal::OptionalNone(),JaktInternal::OptionalNone()))));
 }
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
-DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
-types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
 
-if (((TRY((((*this).find_functions_with_name_in_scope(((struct_).scope_id),name))))).has_value())){
-continue;
-}
-NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
-if (((((((function)->block)).statements)).is_empty())){
-continue;
 }
-NonnullRefPtr<types::CheckedFunction> replaced_function = TRY((((function)->copy())));
-types::GenericInferences const inferences = ((*this).generic_inferences);
-TRY((((replaced_function)->map_types((([inferences](types::TypeId type_id) -> ErrorOr<types::TypeId> {
-{
-return (TRY((((inferences).map(type_id)))));
-}
-}
-))))));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::FunctionId const new_function_id = TRY((((module)->add_function(replaced_function))));
-TRY((((*this).add_function_to_scope(((struct_).scope_id),name,(TRY((DynamicArray<types::FunctionId>::create_with({new_function_id})))),((trait_name).name_span)))));
 }
 
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+{
+JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+parser::ParsedRecord record = (_magic_value.value());
+{
+types::ScopeId const record_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((record).record_type);
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_415; {
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
+if ((!(((struct_id).has_value())))){
+return JaktInternal::LoopContinue{};
 }
+__jakt_var_415 = ((((*this).get_struct((struct_id.value())))).scope_id); goto __jakt_label_395;
 
 }
-else {
-continue;
-}
-
+__jakt_label_395:; __jakt_var_415.release_value(); }));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_416; {
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
+if ((!(((struct_id).has_value())))){
+return JaktInternal::LoopContinue{};
 }
+__jakt_var_416 = ((((*this).get_struct((struct_id.value())))).scope_id); goto __jakt_label_396;
 
 }
+__jakt_label_396:; __jakt_var_416.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_417; {
+JaktInternal::Optional<types::EnumId> const enum_id = TRY((((((*this).program))->find_enum_in_scope(scope_id,((record).name)))));
+if ((!(((enum_id).has_value())))){
+return JaktInternal::LoopContinue{};
 }
+__jakt_var_417 = ((((*this).get_enum((enum_id.value())))).scope_id); goto __jakt_label_397;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_397:; __jakt_var_417.release_value(); }));
 };/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-{
-types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
+}/*switch end*/
+}()
+));
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((record).methods)).iterator());
 for (;;){
 JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
@@ -457,186 +458,133 @@ break;
 }
 parser::ParsedMethod method = (_magic_value.value());
 {
-JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
-if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
-(this_arg_type_id = for_type);
-}
-TRY((((*this).typecheck_function_predecl(((method).parsed_function),((enum_).scope_id),this_arg_type_id,JaktInternal::OptionalNone()))));
-}
-
-}
-}
-
-TRY((((*this).fill_trait_implementation_list(((implementation).traits),((((enum_).trait_implementations))),((enum_).scope_id),scope_id))));
+if (((!(((((record).generic_parameters)).is_empty()))) || (!(((((((method).parsed_function)).generic_parameters)).is_empty()))))){
+NonnullRefPtr<types::CheckedFunction> func = ((*this).get_function((TRY((((*this).find_function_matching_signature_in_scope(record_scope_id,((method).parsed_function))))).value())));
+types::ScopeId const method_scope_id = ((func)->function_scope_id);
+types::ScopeId const check_scope = TRY((((*this).create_scope(method_scope_id,((func)->can_throw),TRY((__jakt_format(Jakt::DeprecatedString("method-checking({}::{})"sv),((record).name),((func)->name)))),true))));
 {
-JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((((implementation).traits)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((func)->params)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
-{
-JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((trait_name).name)))));
-if (((trait_id).has_value())){
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait((trait_id.value())));
+types::CheckedParameter param = (_magic_value.value());
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).add_var_to_scope(check_scope,((((param).variable))->name),TRY((((module)->add_variable(((param).variable))))),((((param).variable))->definition_span)))));
 }
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
-DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
-types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
 
-if (((TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),name))))).has_value())){
-continue;
-}
-NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
-if (((((((function)->block)).statements)).is_empty())){
-continue;
-}
-NonnullRefPtr<types::CheckedFunction> replaced_function = TRY((((function)->copy())));
-types::GenericInferences const inferences = ((*this).generic_inferences);
-TRY((((replaced_function)->map_types((([inferences](types::TypeId type_id) -> ErrorOr<types::TypeId> {
-{
-return (TRY((((inferences).map(type_id)))));
-}
 }
-))))));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::FunctionId const new_function_id = TRY((((module)->add_function(replaced_function))));
-TRY((((*this).add_function_to_scope(((enum_).scope_id),name,(TRY((DynamicArray<types::FunctionId>::create_with({new_function_id})))),((trait_name).name_span)))));
 }
 
+bool const old_ignore_errors = ((*this).ignore_errors);
+(((*this).ignore_errors) = true);
+types::CheckedBlock const block = TRY((((*this).typecheck_block(((((method).parsed_function)).block),check_scope, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
+types::TypeId const function_return_type_id = ((func)->return_type_id);
+types::TypeId return_type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } );
+if (((function_return_type_id).equals(types::unknown_type_id()))){
+if ((!(((((block).statements)).is_empty())))){
+if ((((((((block).statements)).last()).value()))->index() == 8 /* Return */)){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const val = (((((((block).statements)).last()).value()))->get<types::CheckedStatement::Return>()).val;
+if (((val).has_value())){
+(return_type_id = TRY((((*this).resolve_type_var((((val.value()))->type()),method_scope_id)))));
+}
 }
 }
-
 }
 else {
-continue;
+(return_type_id = TRY((((*this).resolve_type_var(function_return_type_id,scope_id)))));
 }
 
+(((func)->block) = block);
+(((func)->return_type_id) = return_type_id);
+}
 }
 
 }
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
-{
-types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
-{
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::ParsedMethod method = (_magic_value.value());
-{
-JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
-if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
-(this_arg_type_id = for_type);
+
 }
-TRY((((*this).typecheck_function_predecl(((method).parsed_function),((enum_).scope_id),this_arg_type_id,JaktInternal::OptionalNone()))));
 }
 
 }
+return {};
 }
 
-TRY((((*this).fill_trait_implementation_list(((implementation).traits),((((enum_).trait_implementations))),((enum_).scope_id),scope_id))));
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_set(JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const values,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
 {
-JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((((implementation).traits)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((*this).dump_try_hints)){
+TRY((((*this).dump_try_hint(span))));
+}
+if ((!(((TRY((((*this).get_scope(scope_id)))))->can_throw)))){
+TRY((((*this).error(Jakt::DeprecatedString("Set initialization needs to be in a try statement or a function marked as throws"sv),span))));
+}
+types::TypeId inner_type_id = types::unknown_type_id();
+JaktInternal::Optional<utility::Span> inner_type_span = JaktInternal::OptionalNone();
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> output = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedExpression>>::create_with({}))));
+types::StructId const set_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Set"sv)))));
+JaktInternal::Optional<types::TypeId> inner_hint = JaktInternal::OptionalNone();
+JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const type_hint_ids = TRY((((*this).get_type_ids_from_type_hint_if_struct_ids_match(type_hint,set_struct_id))));
+if (((type_hint_ids).has_value())){
+(inner_hint = (((type_hint_ids.value()))[static_cast<i64>(0LL)]));
 }
-parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
-{
-JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((trait_name).name)))));
-if (((trait_id).has_value())){
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait((trait_id.value())));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedExpression>> _magic = ((values).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedExpression> value = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
-DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
-types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
-
-if (((TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),name))))).has_value())){
-continue;
-}
-NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
-if (((((((function)->block)).statements)).is_empty())){
-continue;
+NonnullRefPtr<typename types::CheckedExpression> const checked_value = TRY((((*this).typecheck_expression(value,scope_id,safety_mode,inner_hint))));
+types::TypeId const current_value_type_id = ((checked_value)->type());
+if (((inner_type_id).equals(types::unknown_type_id()))){
+if ((((current_value_type_id).equals(types::void_type_id())) || ((current_value_type_id).equals(types::unknown_type_id())))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot create a set with values of type void"sv),((value)->span())))));
 }
-NonnullRefPtr<types::CheckedFunction> replaced_function = TRY((((function)->copy())));
-types::GenericInferences const inferences = ((*this).generic_inferences);
-TRY((((replaced_function)->map_types((([inferences](types::TypeId type_id) -> ErrorOr<types::TypeId> {
-{
-return (TRY((((inferences).map(type_id)))));
+(inner_type_id = current_value_type_id);
+(inner_type_span = ((value)->span()));
 }
+else if ((!(((inner_type_id).equals(current_value_type_id))))){
+DeprecatedString const set_type_name = TRY((((*this).type_name(inner_type_id,false))));
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' does not match type '{}' of previous values in set"sv),TRY((((*this).type_name(current_value_type_id,false)))),set_type_name))),((value)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Set was inferred to store type '{}' here"sv),set_type_name))),(inner_type_span.value())))));
 }
-))))));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::FunctionId const new_function_id = TRY((((module)->add_function(replaced_function))));
-TRY((((*this).add_function_to_scope(((enum_).scope_id),name,(TRY((DynamicArray<types::FunctionId>::create_with({new_function_id})))),((trait_name).name_span)))));
+TRY((((output).push(checked_value))));
 }
 
 }
 }
 
+if (((inner_type_id).equals(types::unknown_type_id()))){
+if (((inner_hint).has_value())){
+(inner_type_id = (inner_hint.value()));
 }
 else {
-continue;
+TRY((((*this).error(Jakt::DeprecatedString("Cannot infer generic type for Set<T>"sv),span))));
 }
 
 }
-
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(set_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id})))))))))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::JaktSet>(output,span,type_id,inner_type_id))));
 }
 }
 
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>>> typechecker::Typechecker::find_functions_with_name_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot implement traits for type '{}'"sv),TRY((((*this).type_name(for_type,false))))))),((((implementation).for_type))->span())))));
+return (TRY((((((*this).program))->find_functions_with_name_in_scope(parent_scope_id,function_name)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
 }
 
-}
-}
-
-}
-return {};
-}
-
-bool typechecker::Typechecker::is_struct(types::TypeId const type_id) const {
+bool typechecker::Typechecker::is_class(types::TypeId const type_id) const {
 {
 if (((((*this).get_type(type_id)))->index() == 23 /* Struct */)){
 types::StructId const struct_id = ((((*this).get_type(type_id)))->get<types::Type::Struct>()).value;
-return (((((((*this).get_struct(struct_id))).record_type)).index() == 0 /* Struct */));
+return (((((((*this).get_struct(struct_id))).record_type)).index() == 1 /* Class */));
 }
 else {
 return (false);
@@ -645,400 +593,462 @@ return (false);
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::dump_try_hint(utility::Span const span) const {
-{
-outln(Jakt::DeprecatedString("{{\"type\":\"try\",\"file_id\":{},\"position\":{}}}"sv),((((span).file_id)).id),((span).start));
-}
-return {};
-}
-
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_call(parser::ParsedCall const call,types::ScopeId const caller_scope_id,utility::Span const span,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const this_expr,JaktInternal::Optional<types::StructLikeId> const parent_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> type_hint,bool const must_be_enum_constructor) {
+ErrorOr<types::CheckedVisibility> typechecker::Typechecker::typecheck_visibility(parser::Visibility const visibility,types::ScopeId const scope_id) {
 {
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
-types::TypeId return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } );
-JaktInternal::DynamicArray<types::TypeId> generic_arguments = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-bool callee_throws = false;
-JaktInternal::DynamicArray<types::ResolvedNamespace> resolved_namespaces = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
-JaktInternal::DynamicArray<types::FunctionId> resolved_function_id_candidates = (TRY((DynamicArray<types::FunctionId>::create_with({}))));
-JaktInternal::Optional<types::FunctionId> resolved_function_id = JaktInternal::OptionalNone();
-JaktInternal::Optional<types::TypeId> maybe_this_type_id = JaktInternal::OptionalNone();
-JaktInternal::Optional<types::FunctionId> generic_checked_function_to_instantiate = JaktInternal::OptionalNone();
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-ScopeGuard __jakt_var_414([&] {
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedVisibility, ErrorOr<types::CheckedVisibility>>{
+auto&& __jakt_match_variant = visibility;
+switch(__jakt_match_variant.index()) {
+case 1: {
+return JaktInternal::ExplicitValue( types::CheckedVisibility { typename types::CheckedVisibility::Private() } );
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue( types::CheckedVisibility { typename types::CheckedVisibility::Public() } );
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::Visibility::Restricted>();JaktInternal::DynamicArray<parser::VisibilityRestriction> const& whitelist = __jakt_match_value.whitelist;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::CheckedVisibility> __jakt_var_418; {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> restricted_scopes = (TRY((DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>>::create_with({}))));
 {
-((((*this).generic_inferences)).restore(old_generic_inferences));
+JaktInternal::ArrayIterator<parser::VisibilityRestriction> _magic = ((whitelist).iterator());
+for (;;){
+JaktInternal::Optional<parser::VisibilityRestriction> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-});
+parser::VisibilityRestriction entry = (_magic_value.value());
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((call).namespace_)).iterator());
+NonnullRefPtr<typename types::MaybeResolvedScope> parent_scope = TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Resolved>(scope_id)));
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((entry).namespace_)).iterator());
 for (;;){
 JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString name = (_magic_value.value());
+DeprecatedString ns = (_magic_value.value());
 {
-TRY((((resolved_namespaces).push(types::ResolvedNamespace(name,JaktInternal::OptionalNone(),JaktInternal::OptionalNone())))));
+(parent_scope = TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Unresolved>(parent_scope,ns))));
 }
 
 }
 }
 
-types::ScopeId callee_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = (((parent_id).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = (parent_id.value());
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_415; {
-types::CheckedStruct struct_ = ((*this).get_struct(id));
-types::ScopeId scope_id = ((struct_).scope_id);
-while (((resolved_function_id_candidates).is_empty())){
-bool const old_ignore_errors = ((*this).ignore_errors);
-(((*this).ignore_errors) = true);
-(resolved_function_id_candidates = TRY((((*this).resolve_call(call,resolved_namespaces,span,scope_id,must_be_enum_constructor)))));
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
-if ((!(((resolved_function_id_candidates).is_empty())))){
-break;
-}
-if (((((struct_).super_struct_id)).has_value())){
-types::StructId const parent_struct_id = (((struct_).super_struct_id).value());
-(struct_ = ((*this).get_struct(parent_struct_id)));
-(scope_id = ((struct_).scope_id));
-}
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not find ‘{}’"sv),((call).name)))),span))));
-break;
+NonnullRefPtr<typename types::MaybeResolvedScope> unresolved = TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Unresolved>(parent_scope,((entry).name))));
+TRY((((restricted_scopes).push(TRY((((unresolved)->try_resolve(((*this).program)))))))));
 }
 
 }
-__jakt_var_415 = scope_id; goto __jakt_label_393;
-
 }
-__jakt_label_393:; __jakt_var_415.release_value(); }));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_416; {
-types::ScopeId const scope_id = ((((*this).get_enum(id))).scope_id);
-(resolved_function_id_candidates = TRY((((*this).resolve_call(call,resolved_namespaces,span,scope_id,must_be_enum_constructor)))));
-__jakt_var_416 = scope_id; goto __jakt_label_394;
 
-}
-__jakt_label_394:; __jakt_var_416.release_value(); }));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Trait>();
-types::TraitId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_417; {
-types::ScopeId const scope_id = ((((*this).get_trait(id)))->scope_id);
-(resolved_function_id_candidates = TRY((((*this).resolve_call(call,resolved_namespaces,span,scope_id,must_be_enum_constructor)))));
-__jakt_var_417 = scope_id; goto __jakt_label_395;
+__jakt_var_418 =  types::CheckedVisibility { typename types::CheckedVisibility::Restricted(restricted_scopes,span) } ; goto __jakt_label_398;
 
 }
-__jakt_label_395:; __jakt_var_417.release_value(); }));
+__jakt_label_398:; __jakt_var_418.release_value(); }));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
 }
-else {
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_418; {
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = (((call).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+}
+
+ErrorOr<JaktInternal::Optional<types::Value>> typechecker::Typechecker::find_comptime_binding_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
 {
+return (TRY((((((*this).program))->find_comptime_binding_in_scope(scope_id,name)))));
 }
-return JaktInternal::ExplicitValue<void>();
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_try_block(NonnullRefPtr<typename parser::ParsedStatement> const stmt,DeprecatedString const error_name,utility::Span const error_span,parser::ParsedBlock const catch_block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
 {
+types::ScopeId const try_scope_id = TRY((((*this).create_scope(scope_id,true,Jakt::DeprecatedString("try"sv),true))));
+NonnullRefPtr<typename types::CheckedStatement> const checked_stmt = TRY((((*this).typecheck_statement(stmt,try_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+types::StructId const error_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
+NonnullRefPtr<types::CheckedVariable> const error_decl = TRY((types::CheckedVariable::__jakt_create(error_name,((((*this).get_struct(error_struct_id))).type_id),false,error_span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::VarId const error_id = TRY((((module)->add_variable(error_decl))));
+NonnullRefPtr<types::Scope> const parent_scope = TRY((((*this).get_scope(scope_id))));
+types::ScopeId const catch_scope_id = TRY((((*this).create_scope(scope_id,((parent_scope)->can_throw),Jakt::DeprecatedString("catch"sv),true))));
+TRY((((*this).add_var_to_scope(catch_scope_id,error_name,error_id,error_span))));
+types::CheckedBlock const checked_catch_block = TRY((((*this).typecheck_block(catch_block,catch_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+if (((((checked_catch_block).yielded_type)).has_value())){
+TRY((((*this).error(Jakt::DeprecatedString("A ‘catch’ block as part of a try block is not allowed to yield values"sv),(((catch_block).find_yield_span()).value())))));
 }
-return JaktInternal::ExplicitValue<void>();
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::TryBlock>(checked_stmt,checked_catch_block,error_name,error_span,span,types::void_type_id()))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
+}
+
+ErrorOr<void> typechecker::Typechecker::typecheck_enum_constructor(parser::ParsedRecord const parsed_record,types::EnumId const enum_id,types::ScopeId const parent_scope_id) {
+{
+u64 next_constant_value = static_cast<u64>(0ULL);
+JaktInternal::Set<DeprecatedString> seen_names = (TRY((Set<DeprecatedString>::create_with_values({}))));
+types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = ((enum_).type_id));
+ScopeGuard __jakt_var_419([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+JaktInternal::Set<DeprecatedString> common_seen_fields = (TRY((Set<DeprecatedString>::create_with_values({}))));
+JaktInternal::DynamicArray<types::VarId> common_fields = (TRY((DynamicArray<types::VarId>::create_with({}))));
+JaktInternal::DynamicArray<types::CheckedParameter> common_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
 {
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
+types::CheckedField field = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedVariable> const variable = ((*this).get_variable(((field).variable_id)));
+TRY((((common_params).push(types::CheckedParameter(true,variable,((field).default_value))))));
+TRY((((common_seen_fields).add(((variable)->name)))));
+TRY((((common_fields).push(((field).variable_id)))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
+
+}
+}
+
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((parsed_record).record_type);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::ValueEnum>();NonnullRefPtr<typename parser::ParsedType> const& underlying_type = __jakt_match_value.underlying_type;
+JaktInternal::DynamicArray<parser::ValueEnumVariant> const& variants = __jakt_match_value.variants;
+{
+types::TypeId const underlying_type_id = TRY((((*this).typecheck_typename(underlying_type,parent_scope_id,JaktInternal::OptionalNone()))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
 {
+JaktInternal::ArrayIterator<parser::ValueEnumVariant> _magic = ((variants).iterator());
+for (;;){
+JaktInternal::Optional<parser::ValueEnumVariant> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
+parser::ValueEnumVariant variant = (_magic_value.value());
+{
+if (((seen_names).contains(((variant).name)))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant '{}' is defined more than once"sv),((variant).name)))),((variant).span)))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
+else {
+TRY((((seen_names).add(((variant).name)))));
+NonnullRefPtr<typename types::CheckedExpression> const expr = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>,ErrorOr<void>>{
+auto __jakt_enum_value = (((((variant).value)).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_420; {
+NonnullRefPtr<typename types::CheckedExpression> const value_expression = TRY((((*this).cast_to_underlying((((variant).value).value()),parent_scope_id,underlying_type))));
+JaktInternal::Optional<types::NumberConstant> const number_constant = ((value_expression)->to_number_constant(((*this).program)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<void>>{
+auto __jakt_enum_value = (((number_constant).has_value()));
+if (__jakt_enum_value == true) {
 {
+(next_constant_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<void>>{
+auto&& __jakt_match_variant = (number_constant.value());
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Signed>();
+i64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<u64>(((JaktInternal::checked_add<i64>(val,static_cast<i64>(1LL)))))));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Unsigned>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((JaktInternal::checked_add<u64>(val,static_cast<u64>(1ULL))));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Floating>();
+f64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<u64> __jakt_var_421; {
+utility::todo(Jakt::DeprecatedString("Implement floats"sv));
+__jakt_var_421 = static_cast<u64>(0ULL); goto __jakt_label_400;
+
+}
+__jakt_label_400:; __jakt_var_421.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
 return JaktInternal::ExplicitValue<void>();
 }
 else {
 {
-(resolved_function_id_candidates = TRY((((*this).resolve_call(call,resolved_namespaces,span,caller_scope_id,must_be_enum_constructor)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant '{}' in enum '{}' has a non-constant value: {}"sv),((variant).name),((enum_).name),value_expression))),((variant).span)))));
 }
 return JaktInternal::ExplicitValue<void>();
 }
 return JaktInternal::ExplicitValue<void>();
 }()))
 ;
-__jakt_var_418 = caller_scope_id; goto __jakt_label_396;
+__jakt_var_420 = value_expression; goto __jakt_label_399;
 
 }
-__jakt_label_396:; __jakt_var_418.release_value(); }));
+__jakt_label_399:; __jakt_var_420.release_value(); }));
+}
+else {
+return JaktInternal::ExplicitValue(TRY((((*this).cast_to_underlying(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::NumericConstant>( parser::NumericConstant { typename parser::NumericConstant::U64(((next_constant_value++))) } ,((variant).span)))),parent_scope_id,underlying_type)))));
 }
 }()))
 ;
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> generic_inferences_from_parent = (TRY((Dictionary<DeprecatedString, DeprecatedString>::create_with_entries({}))));
-if ((((parent_id).has_value()) && (((((parent_id.value())).generic_arguments())).has_value()))){
-JaktInternal::DynamicArray<types::TypeId> const arguments = ((((parent_id.value())).generic_arguments()).value());
-JaktInternal::DynamicArray<types::TypeId> const parameters = TRY(((((parent_id.value())).generic_parameters(((((*this).program)))))));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((arguments).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((((enum_).variants)).push( types::CheckedEnumVariant { typename types::CheckedEnumVariant::WithValue(enum_id,((variant).name),expr,((variant).span)) } ))));
+types::VarId const var_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(((variant).name),((enum_).type_id),false,((variant).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())))))));
+TRY((((*this).add_var_to_scope(((enum_).scope_id),((variant).name),var_id,((variant).span)))));
 }
-size_t i = (_magic_value.value());
-{
-TRY((((generic_inferences_from_parent).set(TRY((((((parameters)[i])).to_string()))),TRY((((((arguments)[i])).to_string())))))));
-TRY((((((*this).generic_inferences)).set(TRY((((((parameters)[i])).to_string()))),TRY((((((arguments)[i])).to_string())))))));
+
 }
 
 }
 }
 
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = (((call).name));
-if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::SumEnum>();bool const& is_boxed = __jakt_match_value.is_boxed;
+JaktInternal::DynamicArray<parser::SumEnumVariant> const& variants = __jakt_match_value.variants;
 {
+NonnullRefPtr<types::Module> module = ((*this).current_module());
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+JaktInternal::ArrayIterator<parser::SumEnumVariant> _magic = ((variants).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::SumEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
+parser::SumEnumVariant variant = (_magic_value.value());
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-TRY((((args).push((Tuple{((call).name), checked_arg})))));
+if (((seen_names).contains(((variant).name)))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant '{}' is defined more than once"sv),((variant).name)))),((variant).span)))));
+continue;
 }
-
+TRY((((seen_names).add(((variant).name)))));
+bool const is_structlike = ((((((variant).params)).has_value()) && ((((((variant).params).value())).size()) > static_cast<size_t>(0ULL))) && ((((((((variant).params).value()))[static_cast<i64>(0LL)])).name) != Jakt::DeprecatedString(""sv)));
+bool const is_typed = ((((((variant).params)).has_value()) && ((((((variant).params).value())).size()) == static_cast<size_t>(1ULL))) && ((((((((variant).params).value()))[static_cast<i64>(0LL)])).name) == Jakt::DeprecatedString(""sv)));
+if (is_structlike){
+JaktInternal::Set<DeprecatedString> seen_fields = (TRY((Set<DeprecatedString>::create_with_values({}))));
+{
+JaktInternal::SetIterator<DeprecatedString> _magic = ((common_seen_fields).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+DeprecatedString name = (_magic_value.value());
+{
+TRY((((seen_fields).add(name))));
 }
 
-if ((((call).name) == Jakt::DeprecatedString("format"sv))){
-(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
-(callee_throws = true);
 }
 }
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
-{
+
+JaktInternal::DynamicArray<types::CheckedParameter> params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((common_params).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-TRY((((args).push((Tuple{((call).name), checked_arg})))));
+TRY((((params).push(param))));
 }
 
 }
 }
 
-if ((((call).name) == Jakt::DeprecatedString("format"sv))){
-(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
-(callee_throws = true);
-}
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
-{
+JaktInternal::DynamicArray<types::VarId> fields = (TRY((DynamicArray<types::VarId>::create_with({}))));
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+JaktInternal::ArrayIterator<types::VarId> _magic = ((common_fields).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
+types::VarId field = (_magic_value.value());
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-TRY((((args).push((Tuple{((call).name), checked_arg})))));
+TRY((((fields).push(field))));
 }
 
 }
 }
 
-if ((((call).name) == Jakt::DeprecatedString("format"sv))){
-(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
-(callee_throws = true);
-}
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
 {
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedVarDecl> _magic = (((((variant).params).value())).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedVarDecl> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
+parser::ParsedVarDecl param = (_magic_value.value());
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-TRY((((args).push((Tuple{((call).name), checked_arg})))));
+if (((seen_fields).contains(((param).name)))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant '{}' has a member named '{}' more than once"sv),((variant).name),((param).name)))),((param).span)))));
+continue;
 }
-
+TRY((((seen_fields).add(((param).name)))));
+types::TypeId const type_id = TRY((((*this).typecheck_typename(((param).parsed_type),((enum_).scope_id),((param).name)))));
+NonnullRefPtr<types::CheckedVariable> const checked_var = TRY((types::CheckedVariable::__jakt_create(((param).name),type_id,((param).is_mutable),((param).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
+TRY((((params).push(types::CheckedParameter(true,checked_var,JaktInternal::OptionalNone())))));
+if ((((*this).dump_type_hints) && ((((param).parsed_type))->index() == 13 /* Empty */))){
+TRY((((*this).dump_type_hint(type_id,((param).span)))));
 }
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::VarId const var_id = TRY((((module)->add_variable(checked_var))));
+TRY((((fields).push(var_id))));
 }
 
-if ((((call).name) == Jakt::DeprecatedString("format"sv))){
-(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
-(callee_throws = true);
 }
 }
-return JaktInternal::ExplicitValue<void>();
+
+TRY((((((enum_).variants)).push( types::CheckedEnumVariant { typename types::CheckedEnumVariant::StructLike(enum_id,((variant).name),fields,((variant).span)) } ))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_enum_variant_constructor = TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),((variant).name)))));
+if ((!(((maybe_enum_variant_constructor).has_value())))){
+bool const can_function_throw = is_boxed;
+types::ScopeId const function_scope_id = TRY((((*this).create_scope(parent_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor({}::{})"sv),((enum_).name),((variant).name)))),true))));
+types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor-block({}::{})"sv),((enum_).name),((variant).name)))),true))));
+NonnullRefPtr<types::CheckedFunction> const checked_function = TRY((types::CheckedFunction::__jakt_create(((variant).name),((variant).span), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id))))))),JaktInternal::OptionalNone(),params,TRY((types::FunctionGenerics::__jakt_create(function_scope_id,params,(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false),can_function_throw, parser::FunctionType { typename parser::FunctionType::ImplicitEnumConstructor() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,function_scope_id,JaktInternal::OptionalNone(),true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
+types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
+TRY((((*this).add_function_to_scope(((enum_).scope_id),((variant).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((variant).span)))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
-{
+}
+else if (is_typed){
+JaktInternal::DynamicArray<types::CheckedParameter> params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((common_params).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-TRY((((args).push((Tuple{((call).name), checked_arg})))));
+TRY((((params).push(param))));
 }
 
 }
 }
 
-if ((((call).name) == Jakt::DeprecatedString("format"sv))){
-(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
-(callee_throws = true);
-}
+parser::ParsedVarDecl const param = (((((variant).params).value()))[static_cast<i64>(0LL)]);
+types::TypeId const type_id = TRY((((*this).typecheck_typename(((param).parsed_type),((enum_).scope_id),((param).name)))));
+TRY((((((enum_).variants)).push( types::CheckedEnumVariant { typename types::CheckedEnumVariant::Typed(enum_id,((variant).name),type_id,((variant).span)) } ))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_enum_variant_constructor = TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),((variant).name)))));
+if ((!(((maybe_enum_variant_constructor).has_value())))){
+bool const can_function_throw = is_boxed;
+types::ScopeId const function_scope_id = TRY((((*this).create_scope(parent_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor({}::{})"sv),((enum_).name),((variant).name)))),true))));
+types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor-block({}::{})"sv),((enum_).name),((variant).name)))),true))));
+NonnullRefPtr<types::CheckedVariable> const variable = TRY((types::CheckedVariable::__jakt_create(Jakt::DeprecatedString("value"sv),type_id,false,((param).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
+TRY((((params).push(types::CheckedParameter(false,variable,JaktInternal::OptionalNone())))));
+NonnullRefPtr<types::CheckedFunction> const checked_function = TRY((types::CheckedFunction::__jakt_create(((variant).name),((variant).span), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id))))))),JaktInternal::OptionalNone(),params,TRY((types::FunctionGenerics::__jakt_create(function_scope_id,params,(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } ,types::TypeId::none(),false),can_function_throw, parser::FunctionType { typename parser::FunctionType::ImplicitEnumConstructor() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,function_scope_id,JaktInternal::OptionalNone(),true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
+types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
+TRY((((*this).add_function_to_scope(((enum_).scope_id),((variant).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((variant).span)))));
 }
-return JaktInternal::ExplicitValue<void>();
 }
 else {
+JaktInternal::DynamicArray<types::CheckedParameter> params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
 {
-i64 max_found_specificity = (-(static_cast<i64>(1LL)));
-JaktInternal::DynamicArray<error::JaktError> errors_while_trying_to_find_matching_function = (TRY((DynamicArray<error::JaktError>::create_with({}))));
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> generic_inferences_for_best_match = (TRY((Dictionary<DeprecatedString, DeprecatedString>::create_with_entries({}))));
-{
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((resolved_function_id_candidates).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((common_params).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId candidate = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = TRY((((*this).match_function_and_resolve_args(call,caller_scope_id,candidate,safety_mode,span,this_expr))));
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typechecker::FunctionMatchResult::MatchSuccess>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& resolved_args = __jakt_match_value.args;
-JaktInternal::Optional<types::TypeId> const& resolved_this_type_id = __jakt_match_value.maybe_this_type_id;
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const& used_generic_inferences = __jakt_match_value.used_generic_inferences;
-i64 const& specificity = __jakt_match_value.specificity;
-{
-if ((specificity > max_found_specificity)){
-(resolved_function_id = candidate);
-(maybe_this_type_id = resolved_this_type_id);
-(max_found_specificity = specificity);
-(generic_inferences_for_best_match = used_generic_inferences);
-(args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({})))));
+types::CheckedParameter param = (_magic_value.value());
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((resolved_args).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((params).push(param))));
 }
-NonnullRefPtr<typename types::CheckedExpression> resolved_arg = (_magic_value.value());
-{
-TRY((((args).push((Tuple{((call).name), resolved_arg})))));
+
+}
+}
+
+TRY((((((enum_).variants)).push( types::CheckedEnumVariant { typename types::CheckedEnumVariant::Untyped(enum_id,((variant).name),((variant).span)) } ))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_enum_variant_constructor = TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),((variant).name)))));
+if ((!(((maybe_enum_variant_constructor).has_value())))){
+bool const can_function_throw = is_boxed;
+types::ScopeId const function_scope_id = TRY((((*this).create_scope(parent_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor({}::{})"sv),((enum_).name),((variant).name)))),true))));
+types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor-block({}::{})"sv),((enum_).name),((variant).name)))),true))));
+NonnullRefPtr<types::CheckedFunction> const checked_function = TRY((types::CheckedFunction::__jakt_create(((variant).name),((variant).span), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id))))))),JaktInternal::OptionalNone(),params,TRY((types::FunctionGenerics::__jakt_create(function_scope_id,params,(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } ,types::TypeId::none(),false),can_function_throw, parser::FunctionType { typename parser::FunctionType::ImplicitEnumConstructor() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,function_scope_id,JaktInternal::OptionalNone(),true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
+types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
+TRY((((*this).add_function_to_scope(((enum_).scope_id),((variant).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((variant).span)))));
+}
+}
+
 }
 
 }
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typechecker::FunctionMatchResult::MatchError>();JaktInternal::DynamicArray<error::JaktError> const& errors = __jakt_match_value.errors;
+}/*switch end*/
+}()
+));
+}
+return {};
+}
+
+ErrorOr<void> typechecker::Typechecker::typecheck_trait(parser::ParsedTrait const parsed_trait,types::TraitId const trait_id,types::ScopeId const scope_id) {
 {
+NonnullRefPtr<types::CheckedTrait> const checked_trait = ((((((((((*this).program))->modules))[((((trait_id).module)).id)]))->traits))[((trait_id).id)]);
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Trait>(trait_id))))))));
+ScopeGuard __jakt_var_422([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
 {
-JaktInternal::ArrayIterator<error::JaktError> _magic = ((errors).iterator());
+JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((parsed_trait).methods)).iterator());
 for (;;){
-JaktInternal::Optional<error::JaktError> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-error::JaktError error = (_magic_value.value());
+parser::ParsedFunction parsed_function = (_magic_value.value());
 {
-TRY((((errors_while_trying_to_find_matching_function).push(error))));
-}
-
+if (((((((parsed_function).block)).stmts)).is_empty())){
+continue;
 }
+TRY((((*this).typecheck_function(parsed_function,((checked_trait)->scope_id)))));
 }
 
-return JaktInternal::LoopContinue{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
 }
 
 }
+return {};
 }
 
-if ((!(((resolved_function_id).has_value())))){
-if ((!(((resolved_function_id_candidates).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("No function with matching signature found."sv),span))));
+ErrorOr<typechecker::FunctionMatchResult> typechecker::Typechecker::match_function_and_resolve_args(parser::ParsedCall const call,types::ScopeId const caller_scope_id,types::FunctionId const candidate,types::SafetyMode const safety_mode,utility::Span const span,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const this_expr) {
 {
-JaktInternal::ArrayIterator<error::JaktError> _magic = ((errors_while_trying_to_find_matching_function).iterator());
-for (;;){
-JaktInternal::Optional<error::JaktError> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> args = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedExpression>>::create_with({}))));
+JaktInternal::Optional<types::TypeId> maybe_this_type_id = JaktInternal::OptionalNone();
+JaktInternal::DynamicArray<error::JaktError> argument_errors = (TRY((DynamicArray<error::JaktError>::create_with({}))));
+size_t const num_old_compiler_errors = ((((((*this).compiler))->errors)).size());
+NonnullRefPtr<types::CheckedFunction> const callee_candidate = ((*this).get_function(candidate));
+types::ScopeId const scope_containing_callee = (((TRY((((*this).get_scope(((callee_candidate)->function_scope_id))))))->parent).value());
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const generic_inference_checkpoint = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+if (((callee_candidate)->is_instantiated)){
+TRY((((((*this).generic_inferences)).perform_checkpoint(true))));
 }
-error::JaktError match_error = (_magic_value.value());
+ScopeGuard __jakt_var_423([&] {
 {
-TRY((((((((*this).compiler))->errors)).push(match_error))));
+((((*this).generic_inferences)).restore(generic_inference_checkpoint));
 }
 
+});
+if (((((callee_candidate)->type)).index() == 2 /* ImplicitConstructor */)){
+types::CheckedStruct const struct_ = ((*this).get_struct((((callee_candidate)->struct_id).value())));
+TRY((((*this).check_implicit_constructor_argument_access(caller_scope_id,call,struct_))));
 }
+else {
+TRY((((*this).check_method_access(caller_scope_id,scope_containing_callee,callee_candidate,span))));
 }
 
-}
-JaktInternal::DynamicArray<types::TypeId> checked_type_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+size_t type_arg_index = static_cast<size_t>(0ULL);
 {
 JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((call).type_args)).iterator());
 for (;;){
@@ -1046,763 +1056,719 @@ JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedType> type_arg = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedType> parsed_type = (_magic_value.value());
 {
-TRY((((checked_type_args).push(TRY((((*this).typecheck_typename(type_arg,caller_scope_id,JaktInternal::OptionalNone()))))))));
-}
+types::TypeId const checked_type = TRY((((*this).typecheck_typename(parsed_type,caller_scope_id,JaktInternal::OptionalNone()))));
+if ((((((((callee_candidate)->generics))->params)).size()) <= type_arg_index)){
+TRY((((*this).error(Jakt::DeprecatedString("Trying to access generic parameter out of bounds"sv),((parsed_type)->span())))));
+continue;
+}
+types::TypeId const typevar_type_id = ((((((((callee_candidate)->generics))->params))[type_arg_index])).type_id());
+if ((!(((typevar_type_id).equals(checked_type))))){
+TRY((((((*this).generic_inferences)).set(TRY((((typevar_type_id).to_string()))),TRY((((checked_type).to_string())))))));
+}
+({auto& _jakt_ref = type_arg_index;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+}
 
 }
 }
 
+size_t arg_offset = static_cast<size_t>(0ULL);
+if (((this_expr).has_value())){
+types::TypeId const type_id = (((this_expr.value()))->type());
+(maybe_this_type_id = type_id);
+NonnullRefPtr<typename types::Type> const param_type = ((*this).get_type(type_id));
+if (((param_type)->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((param_type)->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((param_type)->get<types::Type::GenericInstance>()).args;
+types::CheckedStruct const structure = ((*this).get_struct(id));
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((structure).generic_parameters)).size()))});
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-TRY((((args).push((Tuple{((call).name), checked_arg})))));
+if (((((((((structure).generic_parameters))[i])).type_id)).equals(((args)[i])))){
+continue;
+}
+TRY((((((*this).generic_inferences)).set(TRY((((((((((structure).generic_parameters))[i])).type_id)).to_string()))),TRY((((((args)[i])).to_string())))))));
 }
 
 }
 }
 
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Call>(types::CheckedCall(resolved_namespaces,((call).name),args,checked_type_args,JaktInternal::OptionalNone(),types::builtin( types::BuiltinType { typename types::BuiltinType::Unknown() } ),callee_throws,JaktInternal::OptionalNone()),span,types::builtin( types::BuiltinType { typename types::BuiltinType::Unknown() } )))));
 }
-((((*this).generic_inferences)).restore(generic_inferences_for_best_match));
-TRY((((((*this).generic_inferences)).set_from(generic_inferences_from_parent))));
-NonnullRefPtr<types::CheckedFunction> const callee = ((*this).get_function((resolved_function_id.value())));
-(callee_throws = ((callee)->can_throw));
-(return_type = ((callee)->return_type_id));
-if ((((type_hint).has_value()) && (!(((((type_hint).value())).equals(types::unknown_type_id())))))){
-bool const old_ignore_errors = ((*this).ignore_errors);
-(((*this).ignore_errors) = true);
-TRY((((*this).check_types_for_compat(return_type,(type_hint.value()),((((*this).generic_inferences))),span))));
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
+if (((callee_candidate)->is_static())){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot call static method on an instance of an object"sv),span))));
 }
-(return_type = TRY((((*this).substitute_typevars_in_type(return_type,((*this).generic_inferences))))));
-if ((((type_hint).has_value()) && (!(((((type_hint).value())).equals(types::unknown_type_id())))))){
-bool const old_ignore_errors = ((*this).ignore_errors);
-if (((callee)->is_instantiated)){
-(((*this).ignore_errors) = true);
+else {
+(arg_offset = static_cast<size_t>(1ULL));
+}
+
+if ((((callee_candidate)->is_mutating()) && (!((((this_expr.value()))->is_mutable(((*this).program))))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot call mutating method on an immutable object instance"sv),span))));
 }
-TRY((((*this).check_types_for_compat((type_hint.value()),return_type,((((*this).generic_inferences))),span))));
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
 }
+else if ((!(((callee_candidate)->is_static())))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Cannot call an instance method statically"sv),span,Jakt::DeprecatedString("Add a dot before the method name to call an instance method"sv),span))));
+}
+i64 total_function_specificity = static_cast<i64>(0LL);
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>> const resolved_args = TRY((((*this).resolve_default_params(((((callee_candidate)->generics))->base_params),((call).args),caller_scope_id,safety_mode,arg_offset,span))));
+if ((((((((callee_candidate)->generics))->base_params)).size()) == (JaktInternal::checked_add<size_t>(((resolved_args).size()),arg_offset)))){
 {
-JaktInternal::ArrayIterator<types::FunctionGenericParameter> _magic = ((((((callee)->generics))->params)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>((JaktInternal::checked_sub<size_t>(((((((callee_candidate)->generics))->base_params)).size()),arg_offset)))});
 for (;;){
-JaktInternal::Optional<types::FunctionGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionGenericParameter generic_typevar = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-if (((((generic_typevar).kind)).index() == 1 /* Parameter */)){
-JaktInternal::Optional<DeprecatedString> const substitution = ((((*this).generic_inferences)).get(TRY((((((generic_typevar).type_id())).to_string())))));
-if (((substitution).has_value())){
-TRY((((generic_arguments).push(TRY((types::TypeId::from_string((substitution.value()))))))));
-}
-else if ((!(((*this).in_comptime_function_call)))){
-TRY((((*this).error(Jakt::DeprecatedString("Not all generic parameters have known types"sv),span))));
-}
-else {
-TRY((((generic_arguments).push(((generic_typevar).type_id())))));
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>> const name_span_checked_arg_ = ((resolved_args)[i]);
+DeprecatedString const name = ((name_span_checked_arg_).template get<0>());
+utility::Span const span = ((name_span_checked_arg_).template get<1>());
+NonnullRefPtr<typename types::CheckedExpression> const checked_arg = ((name_span_checked_arg_).template get<2>());
+
+NonnullRefPtr<typename types::Type> const type_to = ((*this).get_type(((((((((((callee_candidate)->generics))->base_params))[(JaktInternal::checked_add<size_t>(i,arg_offset))])).variable))->type_id)));
+({auto& _jakt_ref = total_function_specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((type_to)->specificity(((*this).program),(static_cast<i64>(1LL) << static_cast<i64>(31LL)))));});
+TRY((((*this).check_types_for_compat(((((((((((callee_candidate)->generics))->base_params))[(JaktInternal::checked_add<size_t>(i,arg_offset))])).variable))->type_id),((checked_arg)->type()),((((*this).generic_inferences))),((checked_arg)->span())))));
+TRY((((args).push(checked_arg))));
 }
 
 }
 }
 
 }
+size_t const num_match_errors = (JaktInternal::checked_sub<size_t>(((((((*this).compiler))->errors)).size()),num_old_compiler_errors));
+if ((num_match_errors > static_cast<size_t>(0ULL))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(num_match_errors)});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t error_index = (_magic_value.value());
+{
+TRY((((argument_errors).push((((((((*this).compiler))->errors)).pop()).value())))));
 }
 
-if (((!(((callee)->is_instantiated))) || ((!(((((callee)->linkage)).index() == 1 /* External */))) && (!(((((callee)->generics))->is_specialized_for_types(generic_arguments))))))){
-(generic_checked_function_to_instantiate = static_cast<JaktInternal::Optional<types::FunctionId>>((resolved_function_id.value())));
 }
-else if (((callee)->is_instantiated)){
-if ((((type_hint).has_value()) && (!(((((type_hint).value())).equals(types::unknown_type_id())))))){
-TRY((((*this).check_types_for_compat((type_hint.value()),return_type,((((*this).generic_inferences))),span))));
 }
+
+return ( typechecker::FunctionMatchResult { typename typechecker::FunctionMatchResult::MatchError(argument_errors) } );
 }
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const used_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+return ( typechecker::FunctionMatchResult { typename typechecker::FunctionMatchResult::MatchSuccess(args,maybe_this_type_id,used_inferences,total_function_specificity) } );
 }
-return JaktInternal::ExplicitValue<void>();
 }
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-(return_type = TRY((((*this).substitute_typevars_in_type(return_type,((*this).generic_inferences))))));
-if ((callee_throws && (!(((TRY((((*this).get_scope(caller_scope_id)))))->can_throw))))){
-TRY((((*this).error(Jakt::DeprecatedString("Call to function that may throw needs to be in a try statement or a function marked as throws"sv),span))));
+
+ErrorOr<types::TypeId> typechecker::Typechecker::unify_with_type(types::TypeId const found_type,JaktInternal::Optional<types::TypeId> const expected_type,utility::Span const span) {
+{
+if ((!(((expected_type).has_value())))){
+return (found_type);
 }
-if (((generic_checked_function_to_instantiate).has_value())){
-if (((maybe_this_type_id).has_value())){
-(maybe_this_type_id = TRY((((*this).substitute_typevars_in_type((maybe_this_type_id.value()),((*this).generic_inferences))))));
+if ((((expected_type.value())).equals(types::unknown_type_id()))){
+return (found_type);
 }
-(resolved_function_id = TRY((((*this).typecheck_and_specialize_generic_function((generic_checked_function_to_instantiate.value()),generic_arguments,callee_scope_id,maybe_this_type_id,((*this).generic_inferences),((call).type_args),span,args)))));
+if (TRY((((*this).check_types_for_compat((expected_type.value()),found_type,((((*this).generic_inferences))),span))))){
+return (found_type);
 }
-if ((((*this).dump_try_hints) && callee_throws)){
-TRY((((*this).dump_try_hint(span))));
+return (TRY((((*this).substitute_typevars_in_type(found_type,((*this).generic_inferences))))));
 }
-JaktInternal::Optional<DeprecatedString> const external_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<DeprecatedString>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = (((resolved_function_id).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_419; {
-NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function((resolved_function_id.value())));
-if (((((function)->deprecated_message)).has_value())){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Call to deprecated function: {}"sv),(((function)->deprecated_message).value())))),span))));
 }
-__jakt_var_419 = ((function)->external_name); goto __jakt_label_397;
 
+bool typechecker::Typechecker::is_numeric(types::TypeId const type_id) const {
+{
+return (((((*this).program))->is_numeric(type_id)));
 }
-__jakt_label_397:; __jakt_var_419.release_value(); }));
-}
-else {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
 }
-}()))
-;
-if (((resolved_function_id).has_value())){
-NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function((resolved_function_id.value())));
-if (((((function)->stores_arguments)).has_value())){
-JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> const argument_behaviour = (((function)->stores_arguments).value());
+
+ErrorOr<types::StructId> typechecker::Typechecker::find_struct_in_prelude(DeprecatedString const name) const {
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> _magic = ((argument_behaviour).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (TRY((((((*this).program))->find_struct_in_prelude(name)))));
+}
 }
-JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel> index__level__ = (_magic_value.value());
-{
-JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel> const jakt__index__level__ = index__level__;
-size_t const index = ((jakt__index__level__).template get<0>());
-parser::ArgumentStoreLevel const level = ((jakt__index__level__).template get<1>());
 
-Function<NonnullRefPtr<typename types::CheckedExpression>(size_t)> const resolve_arg = [&args, &this_expr, &function](size_t index) -> NonnullRefPtr<typename types::CheckedExpression> {
+types::CheckedStruct typechecker::Typechecker::get_struct(types::StructId const id) const {
 {
-if (((function)->is_static())){
-return (((((args)[index])).template get<1>()));
+return (((((*this).program))->get_struct(id)));
 }
-if ((index == static_cast<size_t>(0ULL))){
-return ((this_expr.value()));
 }
-return (((((args)[(JaktInternal::checked_sub<size_t>(index,static_cast<size_t>(1ULL)))])).template get<1>()));
+
+types::CheckedEnum typechecker::Typechecker::get_enum(types::EnumId const id) const {
+{
+return (((((*this).program))->get_enum(id)));
 }
 }
-;
-JaktInternal::Optional<types::ScopeId> const arg_scope_id = TRY((((*this).required_scope_id_in_hierarchy_for(resolve_arg(index),caller_scope_id))));
-JaktInternal::Optional<types::ScopeId> const stored_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = level;
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::dereference_if_needed(NonnullRefPtr<typename types::CheckedExpression> const checked_expr,utility::Span const span) {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(((checked_expr)->type())));
 switch(__jakt_match_variant.index()) {
-case 1: {
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::ScopeId>>(((*this).root_scope_id())));
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Dereference() } ,span,type_id))));
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ArgumentStoreLevel::InObject>();size_t const& argument_index = __jakt_match_value.argument_index;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(resolve_arg(argument_index),caller_scope_id)))));
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Dereference() } ,span,type_id))));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+default: {
+return JaktInternal::ExplicitValue(checked_expr);
+};/*case end*/
+}/*switch end*/
 }()
-));
-if (TRY((((*this).scope_lifetime_subsumes(stored_scope_id,arg_scope_id))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot pass this argument by reference, it is not guaranteed to outlive the object it will be stored in"sv),((resolve_arg(index))->span())))));
+)));
 }
 }
 
+ErrorOr<void> typechecker::Typechecker::dump_type_hint(types::TypeId const type_id,utility::Span const span) const {
+{
+outln(Jakt::DeprecatedString("{{\"type\":\"hint\",\"file_id\":{},\"position\":{},\"typename\":\"{}\"}}"sv),((((span).file_id)).id),((span).end),TRY((((*this).type_name(type_id,false)))));
 }
+return {};
 }
 
+ErrorOr<void> typechecker::Typechecker::fill_trait_implementation_list(JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> const parsed_impl_list,JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>& trait_implementations,types::ScopeId const scope_id,JaktInternal::Optional<types::ScopeId> const trait_name_scope_id_override) {
+{
+types::ScopeId const trait_name_scope_id = trait_name_scope_id_override.value_or_lazy_evaluated([&] { return scope_id; });
+{
+JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((parsed_impl_list).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-}
-types::CheckedCall const function_call = types::CheckedCall(resolved_namespaces,((call).name),args,generic_arguments,resolved_function_id,return_type,callee_throws,external_name);
-NonnullRefPtr<typename types::CheckedExpression> const checked_call = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Call>(function_call,span,return_type)));
-bool const in_comptime_function = (((((*this).current_function_id)).has_value()) && ((((*this).get_function(((((*this).current_function_id)).value()))))->is_comptime));
-if (((!(in_comptime_function)) && (((resolved_function_id).has_value()) && ((((*this).get_function((resolved_function_id.value()))))->is_comptime)))){
-NonnullRefPtr<types::CheckedFunction> const resolved_function = ((*this).get_function((resolved_function_id.value())));
-NonnullRefPtr<interpreter::Interpreter> interpreter = TRY((((*this).interpreter())));
-NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(generic_checked_function_to_instantiate.value_or_lazy_evaluated([&] { return (resolved_function_id.value()); })));
-JaktInternal::DynamicArray<types::Value> call_args = (TRY((DynamicArray<types::Value>::create_with({}))));
-JaktInternal::Optional<types::Value> this_argument = JaktInternal::OptionalNone();
-NonnullRefPtr<interpreter::InterpreterScope> eval_scope = TRY((interpreter::InterpreterScope::from_runtime_scope(caller_scope_id,((*this).program),JaktInternal::OptionalNone())));
+parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
 {
-JaktInternal::DictionaryIterator<DeprecatedString,DeprecatedString> _magic = ((((((*this).generic_inferences)).iterator())).iterator());
+JaktInternal::Optional<types::TypeId> const maybe_type_id = TRY((((*this).find_type_in_scope(trait_name_scope_id,((trait_name).name)))));
+if (((maybe_type_id).has_value())){
+if (((((*this).get_type((maybe_type_id.value()))))->index() == 26 /* Trait */)){
+types::TraitId const trait_id = ((((*this).get_type((maybe_type_id.value()))))->get<types::Type::Trait>()).value;
+JaktInternal::DynamicArray<types::TypeId> generic_arguments = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((trait_name).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> entry = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedType> argument = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> const key_value_ = entry;
-DeprecatedString const key = ((key_value_).template get<0>());
-DeprecatedString const value = ((key_value_).template get<1>());
-
-TRY((((((eval_scope)->type_bindings)).set(key,TRY((types::TypeId::from_string(value)))))));
+types::TypeId const argument_type_id = TRY((((*this).typecheck_typename(argument,scope_id,JaktInternal::OptionalNone()))));
+TRY((((generic_arguments).push(argument_type_id))));
 }
 
 }
 }
 
-if (((this_expr).has_value())){
-auto __jakt_var_420 = [&]() -> ErrorOr<void> {{
-interpreter::StatementResult const evaluated_this = TRY((((interpreter)->execute_expression((this_expr.value()),eval_scope))));
-if (((evaluated_this).index() == 5 /* JustValue */)){
-types::Value const value = ((evaluated_this).get<interpreter::StatementResult::JustValue>()).value;
-(this_argument = value);
-}
-else if (((evaluated_this).index() == 1 /* Throw */)){
-types::Value const value = ((evaluated_this).get<interpreter::StatementResult::Throw>()).value;
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Error executing this expression (evaluation threw {})"sv),value))),(((this_expr.value()))->span())))));
+TRY((((((trait_implementations))).set(((trait_name).name),(Tuple{trait_id, generic_arguments})))));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Invalid this expression"sv),(((this_expr.value()))->span())))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected ‘{}’ to be a trait"sv),((trait_name).name)))),((trait_name).name_span)))));
+continue;
 }
 
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot find trait ‘{}’"sv),((trait_name).name)))),((trait_name).name_span)))));
+continue;
 }
 
-;return {};}();
-if (__jakt_var_420.is_error()) {{
-TRY((((*this).error(Jakt::DeprecatedString("Error executing this expression"sv),(((this_expr.value()))->span())))));
 }
-};
+
 }
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((args).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> argument = (_magic_value.value());
-{
-interpreter::StatementResult const value = ({ Optional<interpreter::StatementResult> __jakt_var_421;
-auto __jakt_var_422 = [&]() -> ErrorOr<interpreter::StatementResult> { return TRY((((interpreter)->execute_expression(((argument).template get<1>()),eval_scope)))); }();
-if (__jakt_var_422.is_error()) {{
-TRY((((*this).error(Jakt::DeprecatedString("Error in argument"sv),span))));
-continue;
+
 }
-} else {__jakt_var_421 = __jakt_var_422.release_value();
+return {};
 }
-__jakt_var_421.release_value(); });
-if (((value).index() == 1 /* Throw */)){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Compiletime call failed: {}"sv),value))),((((argument).template get<1>()))->span())))));
-break;
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_unary_negate(NonnullRefPtr<typename types::CheckedExpression> const expr,utility::Span const span,types::TypeId const type_id) {
+{
+if (((!(((((*this).program))->is_integer(type_id)))) || ((((*this).program))->is_signed(type_id)))){
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } ,span,type_id))));
 }
-types::Value const evaluated_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = value;
+types::TypeId const flipped_sign_type = TRY((((((*this).get_type(type_id)))->flip_signedness())));
+types::CheckedNumericConstant const constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedNumericConstant, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *expr;
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
-types::Value const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(x);
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NumericConstant>();types::CheckedNumericConstant const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(val);
 };/*case end*/
 default: {
 {
-return Error::from_errno(static_cast<i32>(69));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } ,span,type_id))));
 }
 };/*case end*/
 }/*switch end*/
 }()
 ));
-TRY((((call_args).push(evaluated_value))));
-}
-
+types::NumberConstant const number = (((constant).number_constant()).value());
+size_t const raw_number = ((number).to_usize());
+size_t const max_signed = (infallible_integer_cast<size_t>((((TRY((types::Type::template __jakt_create<typename types::Type::I64>())))->max()))));
+i64 negated_number = static_cast<i64>(0LL);
+if ((raw_number == (JaktInternal::checked_add<size_t>(max_signed,static_cast<size_t>(1ULL))))){
+(negated_number = ((TRY((types::Type::template __jakt_create<typename types::Type::I64>())))->min()));
 }
+if ((raw_number <= max_signed)){
+(negated_number = (JaktInternal::checked_sub<i64>(static_cast<i64>(0LL),(infallible_integer_cast<i64>((raw_number))))));
 }
-
-JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings = (TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({}))));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((((resolved_function)->generics))->params)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+types::NumberConstant const negated_number_constant =  types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((negated_number)))) } ;
+if (((raw_number > (JaktInternal::checked_add<size_t>(max_signed,static_cast<size_t>(1ULL)))) || (!(((negated_number_constant).can_fit_number(flipped_sign_type,((*this).program))))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Negative literal -{} too small for type ‘{}’"sv),raw_number,TRY((((*this).type_name(flipped_sign_type,false))))))),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } ,span,type_id))));
 }
-size_t i = (_magic_value.value());
+types::CheckedNumericConstant const new_constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedNumericConstant, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(flipped_sign_type));
+switch(__jakt_match_variant.index()) {
+case 6: {
+return JaktInternal::ExplicitValue( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I8((infallible_integer_cast<i8>((negated_number)))) } );
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I16((infallible_integer_cast<i16>((negated_number)))) } );
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I32((infallible_integer_cast<i32>((negated_number)))) } );
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I64((infallible_integer_cast<i64>((negated_number)))) } );
+};/*case end*/
+default: {
 {
-types::FunctionGenericParameter const param = ((((((resolved_function)->generics))->params))[i]);
-TRY((((type_bindings).set(TRY((((((param).type_id())).to_string()))),((((function_call).type_args))[i])))));
-}
-
+utility::panic(Jakt::DeprecatedString("Unreachable"sv));
 }
+};/*case end*/
+}/*switch end*/
+}()
+));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>(new_constant,span,type_id))), types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } ,span,flipped_sign_type))));
 }
-
-JaktInternal::Optional<interpreter::ExecutionResult> result = JaktInternal::OptionalNone();
-NonnullRefPtr<interpreter::InterpreterScope> invocation_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),JaktInternal::OptionalNone(),type_bindings)));
-auto __jakt_var_423 = [&]() -> ErrorOr<void> {{
-(result = TRY((((interpreter)->execute((resolved_function_id.value()),resolved_namespaces,this_argument,call_args,span,invocation_scope)))));
 }
 
-;return {};}();
-if (__jakt_var_423.is_error()) {auto error = __jakt_var_423.release_error();{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Compiletime call failed: {}"sv),error))),span))));
-return (checked_call);
-}
-};
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = (result.value());
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_statement(NonnullRefPtr<typename parser::ParsedStatement> const statement,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedStatement>, ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
+auto&& __jakt_match_variant = *statement;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Return>();
-types::Value const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((interpreter::value_to_checked_expression(x,interpreter))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Expression>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Expression>(TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,types::TypeId::none())))),span))));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::UnsafeBlock>();parser::ParsedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Block>(TRY((((*this).typecheck_block(block,scope_id, types::SafetyMode { typename types::SafetyMode::Unsafe() } ,JaktInternal::OptionalNone())))),span))));
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Yield>(TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,type_hint)))),span))));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_return(expr,span,scope_id,safety_mode)))));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Block>();parser::ParsedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_block_statement(block,scope_id,safety_mode,span)))));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::InlineCpp>();parser::ParsedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_inline_cpp(block,span,safety_mode)))));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Throw>();
-types::Value const& x = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_424; {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Compiletime call failed: {}"sv),x))),span))));
-__jakt_var_424 = checked_call; goto __jakt_label_398;
-
-}
-__jakt_label_398:; __jakt_var_424.release_value(); }));
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Defer>();NonnullRefPtr<typename parser::ParsedStatement> const& statement = __jakt_match_value.statement;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_defer(statement,scope_id,safety_mode,span)))));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Loop>();parser::ParsedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_loop(block,scope_id,safety_mode,span)))));
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Throw>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_throw(expr,scope_id,safety_mode,span)))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::While>();NonnullRefPtr<typename parser::ParsedExpression> const& condition = __jakt_match_value.condition;
+parser::ParsedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_while(condition,block,scope_id,safety_mode,span)))));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Continue>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Continue>(span))));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Break>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Break>(span))));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::VarDecl>();parser::ParsedVarDecl const& var = __jakt_match_value.var;
+NonnullRefPtr<typename parser::ParsedExpression> const& init = __jakt_match_value.init;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_var_decl(var,init,scope_id,safety_mode,span)))));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<parser::ParsedVarDecl> const& vars = __jakt_match_value.vars;
+NonnullRefPtr<typename parser::ParsedStatement> const& var_decl = __jakt_match_value.var_decl;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_destructuring_assignment(vars,var_decl,scope_id,safety_mode,span)))));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::If>();NonnullRefPtr<typename parser::ParsedExpression> const& condition = __jakt_match_value.condition;
+parser::ParsedBlock const& then_block = __jakt_match_value.then_block;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const& else_statement = __jakt_match_value.else_statement;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_if(condition,then_block,else_statement,scope_id,safety_mode,span)))));
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Garbage>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Garbage>(span))));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::For>();DeprecatedString const& iterator_name = __jakt_match_value.iterator_name;
+utility::Span const& name_span = __jakt_match_value.name_span;
+bool const& is_destructuring = __jakt_match_value.is_destructuring;
+NonnullRefPtr<typename parser::ParsedExpression> const& range = __jakt_match_value.range;
+parser::ParsedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_for(iterator_name,name_span,is_destructuring,range,block,scope_id,safety_mode,span)))));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+parser::ParsedBlock const& else_block = __jakt_match_value.else_block;
+parser::ParsedBlock const& remaining_code = __jakt_match_value.remaining_code;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_guard(expr,else_block,remaining_code,scope_id,safety_mode,span)))));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
 }
-return (checked_call);
-}
 }
 
-ErrorOr<JaktInternal::Optional<types::ScopeId>> typechecker::Typechecker::scope_lifetime_union(JaktInternal::Optional<types::ScopeId> const first,JaktInternal::Optional<types::ScopeId> const second) const {
+ErrorOr<void> typechecker::Typechecker::typecheck_function(parser::ParsedFunction const parsed_function,types::ScopeId const parent_scope_id) {
 {
-if (((!(((first).has_value()))) || (!(((second).has_value()))))){
-return (JaktInternal::OptionalNone());
-}
-types::ScopeId const first_id = (first.value());
-types::ScopeId const second_id = (second.value());
-if (((first_id).equals(((*this).root_scope_id())))){
-return (second_id);
+bool const in_comptime_function_call = ((*this).in_comptime_function_call);
+ScopeGuard __jakt_var_424([&] {
+(((*this).in_comptime_function_call) = in_comptime_function_call);
+});
+(((*this).in_comptime_function_call) = ((parsed_function).is_comptime));
+if (((!(((((parsed_function).generic_parameters)).is_empty()))) && (!(((parsed_function).must_instantiate))))){
+return {};
 }
-if (((second_id).equals(((*this).root_scope_id())))){
-return (first_id);
+JaktInternal::Optional<types::FunctionId> const function_id = TRY((((*this).find_function_matching_signature_in_scope(parent_scope_id,parsed_function))));
+if (((function_id).has_value())){
+(((*this).current_function_id) = (function_id.value()));
+if ((((parsed_function).name) == Jakt::DeprecatedString("main"sv))){
+TRY((((*this).typecheck_jakt_main(parsed_function,parent_scope_id))));
 }
+NonnullRefPtr<types::CheckedFunction> checked_function = ((*this).get_function((function_id.value())));
+types::ScopeId const function_scope_id = ((checked_function)->function_scope_id);
+parser::FunctionLinkage const function_linkage = ((checked_function)->linkage);
+NonnullRefPtr<types::Module> module = ((*this).current_module());
 {
-JaktInternal::Optional<types::ScopeId> scope_id = static_cast<JaktInternal::Optional<types::ScopeId>>(first_id);
-while (((scope_id).has_value())){
-if ((((scope_id.value())).equals(second_id))){
-return (first_id);
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((checked_function)->params)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-(scope_id = ((TRY((((*this).get_scope((scope_id.value()))))))->parent));
+types::CheckedParameter param = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedVariable> const variable = ((param).variable);
+types::VarId const var_id = TRY((((module)->add_variable(variable))));
+TRY((((*this).add_var_to_scope(function_scope_id,((variable)->name),var_id,((variable)->definition_span)))));
+}
+
 }
 }
 
-{
-JaktInternal::Optional<types::ScopeId> scope_id = static_cast<JaktInternal::Optional<types::ScopeId>>(second_id);
-while (((scope_id).has_value())){
-if ((((scope_id.value())).equals(first_id))){
-return (second_id);
+types::TypeId function_return_type_id = TRY((((*this).typecheck_typename(((parsed_function).return_type),function_scope_id,JaktInternal::OptionalNone()))));
+if (((!(((parsed_function).is_fat_arrow))) && (((((parsed_function).return_type))->index() == 13 /* Empty */) && (((parsed_function).name) != Jakt::DeprecatedString("main"sv))))){
+(function_return_type_id = types::void_type_id());
 }
-(scope_id = ((TRY((((*this).get_scope((scope_id.value()))))))->parent));
+if (((function_return_type_id).equals(types::never_type_id()))){
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(function_scope_id))));
+(((scope)->can_throw) = true);
+}
+types::CheckedBlock const block = TRY((((*this).typecheck_block(((parsed_function).block),function_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
+if (((((block).yielded_type)).has_value())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Functions are not allowed to yield values"sv),(((((parsed_function).block)).find_yield_span()).value()),Jakt::DeprecatedString("You might want to return instead"sv),(((((parsed_function).block)).find_yield_keyword_span()).value())))));
+}
+types::TypeId const return_type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId,ErrorOr<void>>{
+auto __jakt_enum_value = (((function_return_type_id).equals(types::unknown_type_id())));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((*this).infer_function_return_type(block)));
+}
+else {
+return JaktInternal::ExplicitValue(TRY((((*this).resolve_type_var(function_return_type_id,function_scope_id)))));
+}
+}()))
+;
+if (((!(((function_linkage).index() == 1 /* External */))) && ((!(((return_type_id).equals(types::void_type_id())))) && (!(((((block).control_flow)).always_transfers_control())))))){
+if ((((return_type_id).equals(types::never_type_id())) && (!(((((block).control_flow)).never_returns()))))){
+TRY((((*this).error(Jakt::DeprecatedString("Control reaches end of never-returning function"sv),((parsed_function).name_span)))));
+}
+else if ((!(((((block).control_flow)).never_returns())))){
+TRY((((*this).error(Jakt::DeprecatedString("Control reaches end of non-void function"sv),((parsed_function).name_span)))));
+}
+}
+(((checked_function)->block) = block);
+(((checked_function)->return_type_id) = return_type_id);
+(((*this).current_function_id) = JaktInternal::OptionalNone());
 }
+else {
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("Previously defined function {} not found in scope {}"sv),((parsed_function).name),parent_scope_id)))))));
 }
 
-return (JaktInternal::OptionalNone());
 }
+return {};
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_namespaced_var_or_simple_enum_constructor_call(DeprecatedString const name,JaktInternal::DynamicArray<DeprecatedString> const namespace_,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint,utility::Span const span) {
+ErrorOr<void> typechecker::Typechecker::typecheck_namespace_declarations(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
 {
-JaktInternal::DynamicArray<types::ScopeId> scopes = (TRY((DynamicArray<types::ScopeId>::create_with({scope_id}))));
+JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((namespace_).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString ns = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-types::ScopeId const scope = ((scopes)[(JaktInternal::checked_sub<size_t>(((scopes).size()),static_cast<size_t>(1ULL)))]);
-JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const ns_in_scope = TRY((((*this).find_namespace_in_scope(scope,ns,false))));
-JaktInternal::Optional<types::EnumId> const enum_in_scope = TRY((((((*this).program))->find_enum_in_scope(scope,ns))));
-types::ScopeId next_scope = scope;
-if (((ns_in_scope).has_value())){
-(next_scope = (((ns_in_scope.value())).template get<0>()));
+parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
+types::ScopeId const child_namespace_scope_id = ((children)[i]);
+TRY((((*this).typecheck_namespace_declarations(child_namespace,child_namespace_scope_id))));
 }
-else if (((enum_in_scope).has_value())){
-(next_scope = ((((*this).get_enum((enum_in_scope.value())))).scope_id));
+
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Namespace ‘{}’ not found"sv),ns))),span))));
 }
 
-TRY((((scopes).push(next_scope))));
+{
+JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
+parser::ParsedRecord record = (_magic_value.value());
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((record).record_type);
+switch(__jakt_match_variant.index()) {
+case 0: {
+{
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
+if ((!(((struct_id).has_value())))){
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find struct that has been previous added"sv)))));
 }
+TRY((((*this).typecheck_struct(record,(struct_id.value()),scope_id))));
 }
-
-types::ScopeId const scope = (((scopes).last()).value());
-size_t i = static_cast<size_t>(0ULL);
-size_t const min_length = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = ((((scopes).size()) <= ((namespace_).size())));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((scopes).size()));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+{
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
+if ((!(((struct_id).has_value())))){
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find struct that has been previous added"sv)))));
 }
-else {
-return JaktInternal::ExplicitValue(((namespace_).size()));
+TRY((((*this).typecheck_struct(record,(struct_id.value()),scope_id))));
 }
-}()))
-;
-JaktInternal::DynamicArray<types::CheckedNamespace> checked_namespaces = (TRY((DynamicArray<types::CheckedNamespace>::create_with({}))));
-while ((i < min_length)){
-TRY((((checked_namespaces).push(types::CheckedNamespace(((namespace_)[i]),scope)))));
-((i++));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+{
+JaktInternal::Optional<types::EnumId> const enum_id = TRY((((((*this).program))->find_enum_in_scope(scope_id,((record).name)))));
+if ((!(((enum_id).has_value())))){
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find enum that has been previous added"sv)))));
 }
-JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const var = TRY((((*this).find_var_in_scope(scope,name))));
-if (((var).has_value())){
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NamespacedVar>(checked_namespaces,(var.value()),span))));
+TRY((((*this).typecheck_enum(record,(enum_id.value()),scope_id))));
 }
-parser::ParsedCall const implicit_constructor_call = parser::ParsedCall(namespace_,name,(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({})))));
-NonnullRefPtr<typename types::CheckedExpression> const call_expression = TRY((((*this).typecheck_call(implicit_constructor_call,scope_id,span,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),safety_mode,type_hint,true))));
-types::TypeId const type_id = ((call_expression)->type());
-types::CheckedCall const call = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedCall, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *call_expression;
-switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
-return JaktInternal::ExplicitValue(call);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+{
+JaktInternal::Optional<types::EnumId> const enum_id = TRY((((((*this).program))->find_enum_in_scope(scope_id,((record).name)))));
+if ((!(((enum_id).has_value())))){
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find enum that has been previous added"sv)))));
+}
+TRY((((*this).typecheck_enum(record,(enum_id.value()),scope_id))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_call returned something other than a CheckedCall"sv)))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-if (((((call).function_id)).has_value())){
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Call>(call,span,type_id))));
-}
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Variable '{}' not found"sv),name))),span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NamespacedVar>(checked_namespaces,TRY((types::CheckedVariable::__jakt_create(name,types::unknown_type_id(),false,span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone()))),span))));
-}
 }
 
-NonnullRefPtr<types::Module> typechecker::Typechecker::current_module() const {
-{
-return (((((*this).program))->get_module(((*this).current_module_id))));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::Type>> typechecker::Typechecker::unwrap_type_from_optional_if_needed(NonnullRefPtr<typename types::Type> const type) const {
 {
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-if (((type)->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((type)->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((type)->get<types::Type::GenericInstance>()).args;
-if (((id).equals(optional_struct_id))){
-return (((*this).get_type(((args)[static_cast<i64>(0LL)]))));
+JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((parsed_namespace).functions)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+parser::ParsedFunction fun = (_magic_value.value());
+{
+TRY((((*this).typecheck_function(fun,scope_id))));
 }
-return (type);
+
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_trait(parser::ParsedTrait const parsed_trait,types::TraitId const trait_id,types::ScopeId const scope_id) {
 {
-NonnullRefPtr<types::CheckedTrait> const checked_trait = ((((((((((*this).program))->modules))[((((trait_id).module)).id)]))->traits))[((trait_id).id)]);
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Trait>(trait_id))))))));
-ScopeGuard __jakt_var_425([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
+JaktInternal::ArrayIterator<parser::ParsedExternalTraitImplementation> _magic = ((((parsed_namespace).external_trait_implementations)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedExternalTraitImplementation> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::ParsedExternalTraitImplementation implementation = (_magic_value.value());
 {
-JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((parsed_trait).methods)).iterator());
+types::TypeId const for_type = TRY((((*this).typecheck_typename(((implementation).for_type),scope_id,JaktInternal::OptionalNone()))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = *((*this).get_type(for_type));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+{
+types::CheckedStruct struct_ = ((*this).get_struct(struct_id));
+{
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedFunction parsed_function = (_magic_value.value());
+parser::ParsedMethod method = (_magic_value.value());
 {
-if (((((((parsed_function).block)).stmts)).is_empty())){
-continue;
+if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
+TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } ))));
 }
-TRY((((*this).typecheck_function(parsed_function,((checked_trait)->scope_id)))));
+else {
+TRY((((*this).typecheck_function(((method).parsed_function),((struct_).scope_id)))));
 }
 
-}
 }
 
 }
-return {};
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_indexed_tuple(NonnullRefPtr<typename parser::ParsedExpression> const expr,size_t const index,types::ScopeId const scope_id,bool const is_optional,types::SafetyMode const safety_mode,utility::Span const span) {
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-types::StructId const tuple_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-types::TypeId expr_type_id = types::unknown_type_id();
-if (((((*this).get_type(((checked_expr)->type()))))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(((checked_expr)->type()))))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(((checked_expr)->type()))))->get<types::Type::GenericInstance>()).args;
-if (((id).equals(tuple_struct_id))){
-if (is_optional){
-TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on a non-optional tuple type"sv),span))));
+types::CheckedStruct struct_ = ((*this).get_struct(struct_id));
+{
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-if ((index >= ((args).size()))){
-TRY((((*this).error(Jakt::DeprecatedString("Tuple index past the end of the tuple"sv),span))));
+parser::ParsedMethod method = (_magic_value.value());
+{
+if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
+TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } ))));
 }
 else {
-(expr_type_id = ((args)[index]));
+TRY((((*this).typecheck_function(((method).parsed_function),((struct_).scope_id)))));
 }
 
-}
-else if ((is_optional && ((id).equals(optional_struct_id)))){
-types::TypeId const inner_type_id = ((args)[static_cast<i64>(0LL)]);
-if (((((*this).get_type(inner_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(inner_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(inner_type_id)))->get<types::Type::GenericInstance>()).args;
-if (((id).equals(tuple_struct_id))){
-if ((index >= ((args).size()))){
-TRY((((*this).error(Jakt::DeprecatedString("Optional-chained tuple index past the end of the tuple"sv),span))));
-}
-else {
-(expr_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({((args)[index])}))))))))))));
-}
-
-}
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Optional-chained tuple index used on non-tuple value"sv),span))));
-}
-
-}
-}
-else if (is_optional){
-TRY((((*this).error(Jakt::DeprecatedString("Optional-chained tuple index used on non-tuple value"sv),span))));
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Tuple index used on non-tuple value"sv),span))));
-}
-
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedTuple>(checked_expr,index,span,is_optional,expr_type_id))));
-}
-}
-
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_match(NonnullRefPtr<typename parser::ParsedExpression> const expr,JaktInternal::DynamicArray<parser::ParsedMatchCase> const cases,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
-{
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-types::TypeId const subject_type_id = ((checked_expr)->type());
-NonnullRefPtr<typename types::Type> const type_to_match_on = ((*this).get_type(subject_type_id));
-JaktInternal::DynamicArray<types::CheckedMatchCase> checked_cases = (TRY((DynamicArray<types::CheckedMatchCase>::create_with({}))));
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-ScopeGuard __jakt_var_426([&] {
-{
-((((*this).generic_inferences)).restore(old_generic_inferences));
-}
-
-});
-JaktInternal::Optional<types::TypeId> final_result_type = JaktInternal::OptionalNone();
-if ((((type_hint).has_value()) && ((!((((type_hint.value())).equals(types::unknown_type_id())))) && (!(((((*this).get_type((type_hint.value()))))->index() == 18 /* TypeVariable */)))))){
-(final_result_type = type_hint);
-}
-if (((type_to_match_on)->index() == 20 /* GenericEnumInstance */)){
-types::EnumId const id = ((type_to_match_on)->get<types::Type::GenericEnumInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((type_to_match_on)->get<types::Type::GenericEnumInstance>()).args;
-types::CheckedEnum const enum_ = ((*this).get_enum(id));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((enum_).generic_parameters)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-DeprecatedString const generic = TRY((((((((((enum_).generic_parameters))[i])).type_id)).to_string())));
-DeprecatedString const argument_type = TRY((((((args)[i])).to_string())));
-if ((generic != argument_type)){
-TRY((((((*this).generic_inferences)).set(generic,argument_type))));
-}
 }
 
 }
 }
 
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *type_to_match_on;
-switch(__jakt_match_variant.index()) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
 case 24: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
 types::EnumId const& enum_id = __jakt_match_value.value;
 {
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-bool seen_catch_all = false;
-bool expanded_catch_all = false;
-JaktInternal::Optional<utility::Span> catch_all_span = JaktInternal::OptionalNone();
-JaktInternal::Set<DeprecatedString> covered_variants = (TRY((Set<DeprecatedString>::create_with_values({}))));
-size_t const case_count = ((cases).size());
-size_t current_case_index = static_cast<size_t>(0ULL);
-{
-JaktInternal::ArrayIterator<parser::ParsedMatchCase> _magic = ((cases).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMatchCase> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::ParsedMatchCase case_ = (_magic_value.value());
-{
-{
-JaktInternal::ArrayIterator<parser::ParsedMatchPattern> _magic = ((((case_).patterns)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMatchPattern> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::ParsedMatchPattern pattern = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = pattern;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::EnumVariant>();JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const& variant_names = __jakt_match_value.variant_names;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
-utility::Span const& arguments_span = __jakt_match_value.arguments_span;
-{
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> variant_names_ = variant_names;
-if ((((variant_names_).size()) == static_cast<size_t>(1ULL))){
-JaktInternal::Tuple<DeprecatedString,utility::Span> const temp = ((variant_names_)[static_cast<i64>(0LL)]);
-(variant_names_ = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({(Tuple{((enum_).name), ((((variant_names_)[static_cast<i64>(0LL)])).template get<1>())}), temp})))));
-}
-if (((variant_names_).is_empty())){
-return JaktInternal::LoopContinue{};
-}
-if ((((((variant_names_)[static_cast<i64>(0LL)])).template get<0>()) != ((enum_).name))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case '{}' does not match enum '{}'"sv),((((variant_names_)[static_cast<i64>(0LL)])).template get<0>()),((enum_).name)))),((((variant_names_)[static_cast<i64>(0LL)])).template get<1>())))));
-return JaktInternal::LoopContinue{};
-}
-size_t i = static_cast<size_t>(0ULL);
-JaktInternal::Optional<types::CheckedEnumVariant> matched_variant = JaktInternal::OptionalNone();
-JaktInternal::Optional<size_t> variant_index = JaktInternal::OptionalNone();
+types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedEnumVariant v = (_magic_value.value());
+parser::ParsedMethod method = (_magic_value.value());
 {
-if ((((v).name()) == ((((variant_names_)[static_cast<i64>(1LL)])).template get<0>()))){
-(matched_variant = v);
-(variant_index = i);
+if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
+TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),enum_id) } ))));
 }
-((i++));
+else {
+TRY((((*this).typecheck_function(((method).parsed_function),((enum_).scope_id)))));
 }
 
-}
 }
 
-if ((!(((matched_variant).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum '{}' does not contain a variant named '{}'"sv),((enum_).name),((((variant_names_)[static_cast<i64>(1LL)])).template get<0>())))),((case_).marker_span)))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Match>(checked_expr,(TRY((DynamicArray<types::CheckedMatchCase>::create_with({})))),span,types::unknown_type_id(),false))));
 }
-JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>> const covered_name_checked_match_case_result_type_ = TRY((((*this).typecheck_match_variant(case_,subject_type_id,(variant_index.value()),final_result_type,(matched_variant.value()),variant_arguments,((pattern).defaults()),arguments_span,scope_id,safety_mode))));
-JaktInternal::Optional<DeprecatedString> const covered_name = ((covered_name_checked_match_case_result_type_).template get<0>());
-types::CheckedMatchCase const checked_match_case = ((covered_name_checked_match_case_result_type_).template get<1>());
-JaktInternal::Optional<types::TypeId> const result_type = ((covered_name_checked_match_case_result_type_).template get<2>());
-
-if (((covered_name).has_value())){
-TRY((((covered_variants).add((covered_name.value())))));
 }
-(final_result_type = result_type);
-TRY((((checked_cases).push(checked_match_case))));
+
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::CatchAll>();JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
-utility::Span const& arguments_span = __jakt_match_value.arguments_span;
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
 {
-if ((current_case_index != (JaktInternal::checked_sub<size_t>(case_count,static_cast<size_t>(1ULL))))){
-TRY((((*this).error(Jakt::DeprecatedString("Match else case is only allowed as the last case"sv),((case_).marker_span)))));
-}
-if (seen_catch_all){
-TRY((((*this).error(Jakt::DeprecatedString("Multiple catch-all cases in match are not allowed"sv),((case_).marker_span)))));
-}
-else {
-(seen_catch_all = true);
-}
-
-if ((((variant_arguments).size()) > static_cast<size_t>(0ULL))){
-size_t variant_index = static_cast<size_t>(0ULL);
+types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
+parser::ParsedMethod method = (_magic_value.value());
 {
-if ((!(((covered_variants).contains(((variant).name())))))){
-(expanded_catch_all = true);
-JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>> const covered_name_checked_match_case_result_type_ = TRY((((*this).typecheck_match_variant(case_,subject_type_id,variant_index,final_result_type,variant,variant_arguments,((pattern).defaults()),arguments_span,scope_id,safety_mode))));
-JaktInternal::Optional<DeprecatedString> const covered_name = ((covered_name_checked_match_case_result_type_).template get<0>());
-types::CheckedMatchCase const checked_match_case = ((covered_name_checked_match_case_result_type_).template get<1>());
-JaktInternal::Optional<types::TypeId> const result_type = ((covered_name_checked_match_case_result_type_).template get<2>());
-
-if (((covered_name).has_value())){
-TRY((((covered_variants).add((covered_name.value())))));
-}
-(final_result_type = result_type);
-TRY((((checked_cases).push(checked_match_case))));
-}
-((variant_index++));
-}
-
-}
-}
-
+if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
+TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),enum_id) } ))));
 }
 else {
-types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),Jakt::DeprecatedString("catch-all"sv),true))));
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((pattern).defaults())).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).typecheck_function(((method).parsed_function),((enum_).scope_id)))));
 }
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
-DeprecatedString const _ = ((jakt_____default___).template get<0>());
-parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
 
-NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
-TRY((((defaults).push(checked_var_decl))));
 }
 
 }
 }
 
-JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
-types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
-JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
-
-(final_result_type = result_type);
-types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::CatchAll(defaults,false,checked_body,((case_).marker_span)) } ;
-TRY((((checked_cases).push(checked_match_case))));
-}
-
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
@@ -1819,792 +1785,716 @@ return JaktInternal::ExplicitValue<void>();
 }
 }
 
-((current_case_index++));
-}
-
 }
+return {};
 }
 
-JaktInternal::DynamicArray<DeprecatedString> enum_variant_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-JaktInternal::DynamicArray<DeprecatedString> missing_variants = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+ErrorOr<void> typechecker::Typechecker::typecheck_struct_constructor(parser::ParsedRecord const parsed_record,types::StructId const struct_id,types::ScopeId const scope_id) {
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
+(((*this).current_struct_type_id) = struct_type_id);
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = struct_type_id);
+ScopeGuard __jakt_var_425([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+types::CheckedStruct const struct_ = ((*this).get_struct(struct_id));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructor_ids = TRY((((*this).find_functions_with_name_in_scope(((struct_).scope_id),((parsed_record).name)))));
+if (((constructor_ids).has_value())){
+if ((((((parsed_record).record_type)).index() == 1 /* Class */) && ((((parsed_record).definition_linkage)).index() == 1 /* External */))){
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = (((constructor_ids.value())).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
+types::FunctionId constructor_id = (_magic_value.value());
 {
-TRY((((enum_variant_names).push(((variant).name())))));
+NonnullRefPtr<types::CheckedFunction> func = ((*this).get_function(constructor_id));
+(((func)->linkage) =  parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
 }
 
 }
 }
 
-{
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((enum_variant_names).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-DeprecatedString variant = (_magic_value.value());
-{
-if ((!(((covered_variants).contains(variant))))){
-TRY((((missing_variants).push(variant))));
 }
 }
-
-}
-}
-
-if ((((missing_variants).size()) > static_cast<size_t>(0ULL))){
-if ((!(seen_catch_all))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match expression is not exhaustive, missing variants are: {}"sv),utility::join(missing_variants,Jakt::DeprecatedString(", "sv))))),span))));
-}
-}
-else if ((seen_catch_all && (!(expanded_catch_all)))){
-TRY((((*this).error(Jakt::DeprecatedString("All variants are covered, but an irrefutable pattern is also present"sv),span))));
-}
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
-{
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-bool seen_catch_all = false;
-bool expanded_catch_all = false;
-JaktInternal::Optional<utility::Span> catch_all_span = JaktInternal::OptionalNone();
-JaktInternal::Set<DeprecatedString> covered_variants = (TRY((Set<DeprecatedString>::create_with_values({}))));
-size_t const case_count = ((cases).size());
-size_t current_case_index = static_cast<size_t>(0ULL);
+else if ((!(((((parsed_record).definition_linkage)).index() == 1 /* External */)))){
+bool const constructor_can_throw = ((((parsed_record).record_type)).index() == 1 /* Class */);
+types::ScopeId const function_scope_id = TRY((((*this).create_scope(((struct_).scope_id),constructor_can_throw,TRY((__jakt_format(Jakt::DeprecatedString("generated-constructor({})"sv),((parsed_record).name)))),true))));
+types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,constructor_can_throw,TRY((__jakt_format(Jakt::DeprecatedString("generated-constructor-block({})"sv),((parsed_record).name)))),true))));
+NonnullRefPtr<types::CheckedFunction> checked_constructor = TRY((types::CheckedFunction::__jakt_create(((parsed_record).name),((parsed_record).name_span), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,struct_type_id,JaktInternal::OptionalNone(),(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),TRY((types::FunctionGenerics::__jakt_create(function_scope_id,(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false),constructor_can_throw, parser::FunctionType { typename parser::FunctionType::ImplicitConstructor() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,function_scope_id,struct_id,true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),((parsed_record).external_name),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::FunctionId const function_id = TRY((((module)->add_function(checked_constructor))));
+JaktInternal::DynamicArray<types::StructId> const inheritance_chain = TRY((((*this).struct_inheritance_chain(struct_id))));
+NonnullRefPtr<types::CheckedFunction> func = (((((module)->functions)).last()).value());
 {
-JaktInternal::ArrayIterator<parser::ParsedMatchCase> _magic = ((cases).iterator());
+JaktInternal::ArrayIterator<types::StructId> _magic = ((inheritance_chain).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedMatchCase> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::StructId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMatchCase case_ = (_magic_value.value());
+types::StructId field_struct_id = (_magic_value.value());
 {
 {
-JaktInternal::ArrayIterator<parser::ParsedMatchPattern> _magic = ((((case_).patterns)).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((((*this).get_struct(field_struct_id))).fields)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedMatchPattern> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMatchPattern pattern = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = pattern;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::EnumVariant>();JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const& variant_names = __jakt_match_value.variant_names;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
-utility::Span const& arguments_span = __jakt_match_value.arguments_span;
+types::CheckedField field = (_magic_value.value());
 {
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> variant_names_ = variant_names;
-if ((((variant_names_).size()) == static_cast<size_t>(1ULL))){
-JaktInternal::Tuple<DeprecatedString,utility::Span> const temp = ((variant_names_)[static_cast<i64>(0LL)]);
-(variant_names_ = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({(Tuple{((enum_).name), ((((variant_names_)[static_cast<i64>(0LL)])).template get<1>())}), temp})))));
-}
-if (((variant_names_).is_empty())){
-return JaktInternal::LoopContinue{};
+NonnullRefPtr<types::CheckedVariable> const variable = ((*this).get_variable(((field).variable_id)));
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value = ((field).default_value);
+if (((!(((default_value).has_value()))) && ((((field).default_value_expression)).has_value()))){
+(((field).default_value) = TRY((((*this).typecheck_expression((((field).default_value_expression).value()),block_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,((variable)->type_id))))));
 }
-if ((((((variant_names_)[static_cast<i64>(0LL)])).template get<0>()) != ((enum_).name))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case '{}' does not match enum '{}'"sv),((((variant_names_)[static_cast<i64>(0LL)])).template get<0>()),((enum_).name)))),((((variant_names_)[static_cast<i64>(0LL)])).template get<1>())))));
-return JaktInternal::LoopContinue{};
+TRY((((func)->add_param(types::CheckedParameter(true,variable,((field).default_value))))));
 }
-size_t i = static_cast<size_t>(0ULL);
-JaktInternal::Optional<types::CheckedEnumVariant> matched_variant = JaktInternal::OptionalNone();
-JaktInternal::Optional<size_t> variant_index = JaktInternal::OptionalNone();
-{
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+
 }
-types::CheckedEnumVariant v = (_magic_value.value());
-{
-if ((((v).name()) == ((((variant_names_)[static_cast<i64>(1LL)])).template get<0>()))){
-(matched_variant = v);
-(variant_index = i);
 }
-((i++));
+
 }
 
 }
 }
 
-if ((!(((matched_variant).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum '{}' does not contain a variant named '{}'"sv),((enum_).name),((((variant_names_)[static_cast<i64>(1LL)])).template get<0>())))),((case_).marker_span)))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Match>(checked_expr,(TRY((DynamicArray<types::CheckedMatchCase>::create_with({})))),span,types::unknown_type_id(),false))));
+TRY((((*this).add_function_to_scope(((struct_).scope_id),((parsed_record).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((parsed_record).name_span)))));
 }
-JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>> const covered_name_checked_match_case_result_type_ = TRY((((*this).typecheck_match_variant(case_,subject_type_id,(variant_index.value()),final_result_type,(matched_variant.value()),variant_arguments,((pattern).defaults()),arguments_span,scope_id,safety_mode))));
-JaktInternal::Optional<DeprecatedString> const covered_name = ((covered_name_checked_match_case_result_type_).template get<0>());
-types::CheckedMatchCase const checked_match_case = ((covered_name_checked_match_case_result_type_).template get<1>());
-JaktInternal::Optional<types::TypeId> const result_type = ((covered_name_checked_match_case_result_type_).template get<2>());
-
-if (((covered_name).has_value())){
-TRY((((covered_variants).add((covered_name.value())))));
+(((*this).current_struct_type_id) = JaktInternal::OptionalNone());
 }
-(final_result_type = result_type);
-TRY((((checked_cases).push(checked_match_case))));
+return {};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::CatchAll>();JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
-utility::Span const& arguments_span = __jakt_match_value.arguments_span;
+
+ErrorOr<types::TypeId> typechecker::Typechecker::resolve_type_var(types::TypeId const type_var_type_id,types::ScopeId const scope_id) const {
 {
-if ((current_case_index != (JaktInternal::checked_sub<size_t>(case_count,static_cast<size_t>(1ULL))))){
-TRY((((*this).error(Jakt::DeprecatedString("Match else case is only allowed as the last case"sv),((case_).marker_span)))));
+types::TypeId current_type_id = type_var_type_id;
+for (;;){
+(current_type_id = TRY((((((*this).generic_inferences)).map(current_type_id)))));
+NonnullRefPtr<typename types::Type> const type_var_type = ((*this).get_type(current_type_id));
+if (((type_var_type)->index() == 18 /* TypeVariable */)){
+DeprecatedString const type_name = ((type_var_type)->get<types::Type::TypeVariable>()).name;
+JaktInternal::Optional<types::TypeId> const maybe_found_type_id = TRY((((*this).find_type_in_scope(scope_id,type_name))));
+if (((maybe_found_type_id).has_value())){
+types::TypeId const found_type_id = ((maybe_found_type_id).value());
+if (((found_type_id).equals(current_type_id))){
+return (current_type_id);
 }
-if (seen_catch_all){
-TRY((((*this).error(Jakt::DeprecatedString("Multiple catch-all cases in match are not allowed"sv),((case_).marker_span)))));
+(current_type_id = found_type_id);
 }
 else {
-(seen_catch_all = true);
+return (current_type_id);
 }
 
-if ((((variant_arguments).size()) > static_cast<size_t>(0ULL))){
-size_t variant_index = static_cast<size_t>(0ULL);
-{
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
-{
-if ((!(((covered_variants).contains(((variant).name())))))){
-(expanded_catch_all = true);
-JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>> const covered_name_checked_match_case_result_type_ = TRY((((*this).typecheck_match_variant(case_,subject_type_id,variant_index,final_result_type,variant,variant_arguments,((pattern).defaults()),arguments_span,scope_id,safety_mode))));
-JaktInternal::Optional<DeprecatedString> const covered_name = ((covered_name_checked_match_case_result_type_).template get<0>());
-types::CheckedMatchCase const checked_match_case = ((covered_name_checked_match_case_result_type_).template get<1>());
-JaktInternal::Optional<types::TypeId> const result_type = ((covered_name_checked_match_case_result_type_).template get<2>());
+else {
+return (current_type_id);
+}
 
-if (((covered_name).has_value())){
-TRY((((covered_variants).add((covered_name.value())))));
 }
-(final_result_type = result_type);
-TRY((((checked_cases).push(checked_match_case))));
+return (current_type_id);
 }
-((variant_index++));
 }
 
-}
+ErrorOr<void> typechecker::Typechecker::check_type_argument_requirements(types::TypeId const generic_argument,JaktInternal::DynamicArray<types::TraitId> const constraints,utility::Span const arg_span) {
+{
+if ((!(((constraints).is_empty())))){
+JaktInternal::Tuple<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>,utility::Span> const implemented_traits_decl_span_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>,utility::Span>, ErrorOr<void>>{
+auto&& __jakt_match_variant = *((*this).get_type(generic_argument));
+switch(__jakt_match_variant.index()) {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue((Tuple{((((*this).get_enum(id))).trait_implementations), ((((*this).get_enum(id))).name_span)}));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((Tuple{((((*this).get_enum(id))).trait_implementations), ((((*this).get_enum(id))).name_span)}));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue((Tuple{((((*this).get_struct(id))).trait_implementations), ((((*this).get_struct(id))).name_span)}));
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((Tuple{((((*this).get_struct(id))).trait_implementations), ((((*this).get_struct(id))).name_span)}));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot use ‘{}’ here as only enums, structs and classes can implement the required traits"sv),TRY((((*this).type_name(generic_argument,false))))))),arg_span))));
+{
+return ErrorOr<void>{};
 }
 
+abort();
 }
-else {
-types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),Jakt::DeprecatedString("catch-all"sv),true))));
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+};/*case end*/
+}/*switch end*/
+}()
+));
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const implemented_traits = ((implemented_traits_decl_span_).template get<0>());
+utility::Span const decl_span = ((implemented_traits_decl_span_).template get<1>());
+
 {
-JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((pattern).defaults())).iterator());
+JaktInternal::ArrayIterator<types::TraitId> _magic = ((constraints).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::TraitId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
+types::TraitId constraint = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
-DeprecatedString const _ = ((jakt_____default___).template get<0>());
-parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
-
-NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
-TRY((((defaults).push(checked_var_decl))));
+DeprecatedString const trait_name = ((((((*this).program))->get_trait(constraint)))->name);
+JaktInternal::Optional<JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const implemented_trait = ((implemented_traits).get(trait_name));
+if (((!(((implemented_trait).has_value()))) || (!((((((implemented_trait.value())).template get<0>())).equals(constraint)))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Cannot use ‘{}’ here as it doesn't implement the trait ‘{}’"sv),TRY((((*this).type_name(generic_argument,false)))),trait_name))),arg_span,Jakt::DeprecatedString("Consider implementing the required trait for this type"sv),decl_span))));
+}
 }
 
 }
 }
 
-JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
-types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
-JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
-
-(final_result_type = result_type);
-types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::CatchAll(defaults,false,checked_body,((case_).marker_span)) } ;
-TRY((((checked_cases).push(checked_match_case))));
 }
-
+else {
+return {};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+return {};
 }
 
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>>> typechecker::Typechecker::get_type_ids_from_type_hint_if_struct_ids_match(JaktInternal::Optional<types::TypeId> const type_hint,types::StructId const expected_struct_id) const {
+{
+if ((!(((type_hint).has_value())))){
+return (JaktInternal::OptionalNone());
 }
+if (((TRY((((*this).unwrap_type_from_optional_if_needed(((*this).get_type((type_hint.value()))))))))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((TRY((((*this).unwrap_type_from_optional_if_needed(((*this).get_type((type_hint.value()))))))))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((TRY((((*this).unwrap_type_from_optional_if_needed(((*this).get_type((type_hint.value()))))))))->get<types::Type::GenericInstance>()).args;
+if (((id).equals(expected_struct_id))){
+return (args);
 }
-
-((current_case_index++));
 }
-
+return (JaktInternal::OptionalNone());
 }
 }
 
-JaktInternal::DynamicArray<DeprecatedString> enum_variant_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-JaktInternal::DynamicArray<DeprecatedString> missing_variants = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_generic_arguments_method_call(NonnullRefPtr<typename types::CheckedExpression> const checked_expr,parser::ParsedCall const call,types::ScopeId const scope_id,utility::Span const span,bool const is_optional,types::SafetyMode const safety_mode) {
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> checked_args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
+TRY((((checked_args).ensure_capacity(((((call).args)).size())))));
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> name_____expr__ = (_magic_value.value());
 {
-TRY((((enum_variant_names).push(((variant).name())))));
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const jakt__name_____expr__ = name_____expr__;
+DeprecatedString const name = ((jakt__name_____expr__).template get<0>());
+utility::Span const _ = ((jakt__name_____expr__).template get<1>());
+NonnullRefPtr<typename parser::ParsedExpression> const expr = ((jakt__name_____expr__).template get<2>());
+
+NonnullRefPtr<typename types::CheckedExpression> const checked_arg_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+TRY((((checked_args).push((Tuple{name, checked_arg_expr})))));
 }
 
 }
 }
 
+JaktInternal::DynamicArray<types::TypeId> checked_type_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((enum_variant_names).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((call).type_args)).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString variant = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedType> type_arg = (_magic_value.value());
 {
-if ((!(((covered_variants).contains(variant))))){
-TRY((((missing_variants).push(variant))));
-}
+TRY((((checked_type_args).push(TRY((((*this).typecheck_typename(type_arg,scope_id,JaktInternal::OptionalNone()))))))));
 }
 
 }
 }
 
-if ((((missing_variants).size()) > static_cast<size_t>(0ULL))){
-if ((!(seen_catch_all))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match expression is not exhaustive, missing variants are: {}"sv),utility::join(missing_variants,Jakt::DeprecatedString(", "sv))))),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::MethodCall>(checked_expr,types::CheckedCall((TRY((DynamicArray<types::ResolvedNamespace>::create_with({})))),((call).name),checked_args,checked_type_args,JaktInternal::OptionalNone(),types::unknown_type_id(),false,JaktInternal::OptionalNone()),span,is_optional,types::unknown_type_id()))));
 }
 }
-else if ((seen_catch_all && (!(expanded_catch_all)))){
-TRY((((*this).error(Jakt::DeprecatedString("All variants are covered, but an irrefutable pattern is also present"sv),span))));
+
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_loop(parser::ParsedBlock const parsed_block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+{
+types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(parsed_block,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+if (((((checked_block).yielded_type)).has_value())){
+TRY((((*this).error(Jakt::DeprecatedString("A ‘loop’ block is not allowed to yield values"sv),(((parsed_block).find_yield_span()).value())))));
 }
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Loop>(checked_block,span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 0: {
-{
-TRY((((*this).error(Jakt::DeprecatedString("Can't match on 'void' type"sv),((checked_expr)->span())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-bool is_enum_match = false;
-bool is_value_match = false;
-bool seen_catch_all = false;
-bool all_variants_constant = true;
-size_t const case_count = ((cases).size());
-size_t current_case_index = static_cast<size_t>(0ULL);
+
+ErrorOr<NonnullRefPtr<types::Scope>> typechecker::Typechecker::get_scope(types::ScopeId const id) const {
 {
-JaktInternal::ArrayIterator<parser::ParsedMatchCase> _magic = ((cases).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMatchCase> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (TRY((((((*this).program))->get_scope(id)))));
 }
-parser::ParsedMatchCase case_ = (_magic_value.value());
-{
-{
-JaktInternal::ArrayIterator<parser::ParsedMatchPattern> _magic = ((((case_).patterns)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMatchPattern> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedMatchPattern pattern = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = pattern;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::EnumVariant>();JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const& variant_names = __jakt_match_value.variant_names;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
-utility::Span const& arguments_span = __jakt_match_value.arguments_span;
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_indexed_tuple(NonnullRefPtr<typename parser::ParsedExpression> const expr,size_t const index,types::ScopeId const scope_id,bool const is_optional,types::SafetyMode const safety_mode,utility::Span const span) {
 {
-if (is_value_match){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot have an enum match case in a match expression containing value matches"sv),((case_).marker_span)))));
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+types::StructId const tuple_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+types::TypeId expr_type_id = types::unknown_type_id();
+if (((((*this).get_type(((checked_expr)->type()))))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(((checked_expr)->type()))))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(((checked_expr)->type()))))->get<types::Type::GenericInstance>()).args;
+if (((id).equals(tuple_struct_id))){
+if (is_optional){
+TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on a non-optional tuple type"sv),span))));
 }
-if ((((variant_names).size()) == static_cast<size_t>(0ULL))){
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_match - else - EnumVariant - variant_names.size() == 0"sv)))));
+if ((index >= ((args).size()))){
+TRY((((*this).error(Jakt::DeprecatedString("Tuple index past the end of the tuple"sv),span))));
 }
-(is_enum_match = true);
-types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),TRY((__jakt_format(Jakt::DeprecatedString("catch-enum-variant({})"sv),variant_names))),true))));
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((pattern).defaults())).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else {
+(expr_type_id = ((args)[index]));
 }
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
-DeprecatedString const _ = ((jakt_____default___).template get<0>());
-parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
 
-NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
-TRY((((defaults).push(checked_var_decl))));
 }
-
+else if ((is_optional && ((id).equals(optional_struct_id)))){
+types::TypeId const inner_type_id = ((args)[static_cast<i64>(0LL)]);
+if (((((*this).get_type(inner_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(inner_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(inner_type_id)))->get<types::Type::GenericInstance>()).args;
+if (((id).equals(tuple_struct_id))){
+if ((index >= ((args).size()))){
+TRY((((*this).error(Jakt::DeprecatedString("Optional-chained tuple index past the end of the tuple"sv),span))));
 }
+else {
+(expr_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({((args)[index])}))))))))))));
 }
 
-JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
-types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
-JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
-
-(final_result_type = result_type);
-types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::EnumVariant(defaults,(((((variant_names).last()).value())).template get<0>()),variant_arguments,subject_type_id,static_cast<size_t>(0ULL),new_scope_id,checked_body,((case_).marker_span)) } ;
-TRY((((checked_cases).push(checked_match_case))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::CatchAll>();JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
-{
-if ((current_case_index != (JaktInternal::checked_sub<size_t>(case_count,static_cast<size_t>(1ULL))))){
-TRY((((*this).error(Jakt::DeprecatedString("Match else case is only allowed as the last case"sv),((case_).marker_span)))));
 }
-if (seen_catch_all){
-TRY((((*this).error(Jakt::DeprecatedString("Multiple catch-all cases in match are not allowed"sv),((case_).marker_span)))));
 }
 else {
-(seen_catch_all = true);
+TRY((((*this).error(Jakt::DeprecatedString("Optional-chained tuple index used on non-tuple value"sv),span))));
 }
 
-if ((((variant_arguments).size()) != static_cast<size_t>(0ULL))){
-bool const old_ignore_errors = ((*this).ignore_errors);
-(((*this).ignore_errors) = false);
-TRY((((*this).error(Jakt::DeprecatedString("Bindings aren't allowed in a generic else"sv),((case_).marker_span)))));
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
 }
-types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),Jakt::DeprecatedString("catch-all"sv),true))));
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((pattern).defaults())).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
-DeprecatedString const _ = ((jakt_____default___).template get<0>());
-parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
-
-NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
-TRY((((defaults).push(checked_var_decl))));
+else if (is_optional){
+TRY((((*this).error(Jakt::DeprecatedString("Optional-chained tuple index used on non-tuple value"sv),span))));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Tuple index used on non-tuple value"sv),span))));
 }
 
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedTuple>(checked_expr,index,span,is_optional,expr_type_id))));
 }
 }
 
-JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
-types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
-JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
-
-(final_result_type = result_type);
-types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::CatchAll(defaults,(((variant_arguments).size()) != static_cast<size_t>(0ULL)),checked_body,((case_).marker_span)) } ;
-TRY((((checked_cases).push(checked_match_case))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchPattern::Expression>();
-NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.value;
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_while(NonnullRefPtr<typename parser::ParsedExpression> const condition,parser::ParsedBlock const block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
 {
-if (is_enum_match){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot have a value match case in a match expression containing enum matches"sv),((case_).marker_span)))));
+NonnullRefPtr<typename types::CheckedExpression> const checked_condition = TRY((((*this).typecheck_expression_and_dereference_if_needed(condition,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+if ((!(((((checked_condition)->type())).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
+TRY((((*this).error(Jakt::DeprecatedString("Condition must be a boolean expression"sv),((condition)->span())))));
 }
-(is_value_match = true);
-JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const new_condition_new_then_block_new_else_statement_ = TRY((((*this).expand_context_for_bindings(expr,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),span))));
-NonnullRefPtr<typename parser::ParsedExpression> const new_condition = ((new_condition_new_then_block_new_else_statement_).template get<0>());
-JaktInternal::Optional<parser::ParsedBlock> const new_then_block = ((new_condition_new_then_block_new_else_statement_).template get<1>());
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const new_else_statement = ((new_condition_new_then_block_new_else_statement_).template get<2>());
-
-NonnullRefPtr<typename types::CheckedExpression> const checked_expression = TRY((((*this).typecheck_expression_and_dereference_if_needed(new_condition,scope_id,safety_mode,static_cast<JaktInternal::Optional<types::TypeId>>(subject_type_id),span))));
-if ((!(((((checked_expression)->to_number_constant(((*this).program)))).has_value())))){
-(all_variants_constant = false);
+types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(block,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+if (((((checked_block).yielded_type)).has_value())){
+TRY((((*this).error(Jakt::DeprecatedString("A ‘while’ block is not allowed to yield values"sv),(((block).find_yield_span()).value())))));
 }
-types::TypeId expression_type = ((checked_expression)->type());
-if (((checked_expression)->index() == 9 /* Range */)){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const from = ((checked_expression)->get<types::CheckedExpression::Range>()).from;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const to = ((checked_expression)->get<types::CheckedExpression::Range>()).to;
-if ((((from).has_value()) || ((to).has_value()))){
-if (((from).has_value())){
-(expression_type = (((from.value()))->type()));
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::While>(checked_condition,checked_block,span))));
 }
-else if (((to).has_value())){
-(expression_type = (((to.value()))->type()));
 }
+
+ErrorOr<void> typechecker::Typechecker::typecheck_alias(parser::ParsedAlias const alias,types::ScopeId const scope_id,typechecker::ImportRestrictions const allow) {
+{
+parser::ParsedName const aliased_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ParsedName,ErrorOr<void>>{
+auto __jakt_enum_value = (((((alias).alias_name)).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue((((alias).alias_name).value()));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("There has to be at least a 'from', or a 'to' in a range expression"sv),((expr)->span())))));
-return JaktInternal::LoopContinue{};
+return JaktInternal::ExplicitValue(({ Optional<parser::ParsedName> __jakt_var_426; {
+parser::ParsedNameWithGenericParameters const name = (((((alias).target)).last()).value());
+if ((!(((((name).generic_parameters)).is_empty())))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Cannot alias a generic instance of a type to the type itself"sv)))),((name).name_span),TRY((__jakt_format(Jakt::DeprecatedString("Add an alias name here: 'as <name>'"sv)))),((name).name_span)))));
 }
+__jakt_var_426 = parser::ParsedName(((name).name),((name).name_span)); goto __jakt_label_401;
 
 }
-TRY((((*this).check_types_for_compat(expression_type,subject_type_id,((((*this).generic_inferences))),((case_).marker_span)))));
-if ((!(((((pattern).defaults())).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("Expression patterns cannot have default bindings"sv),((case_).marker_span)))));
+__jakt_label_401:; __jakt_var_426.release_value(); }));
 }
-types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),TRY((__jakt_format(Jakt::DeprecatedString("catch-expression({})"sv),expr))),true))));
-JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
-types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
-JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
-
-(final_result_type = result_type);
-types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::Expression((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),checked_expression,checked_body,((case_).marker_span)) } ;
-TRY((((checked_cases).push(checked_match_case))));
+}()))
+;
+types::ScopeId resolved_scope_id = scope_id;
+JaktInternal::DynamicArray<types::ResolvedNamespace> alias_path = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>((JaktInternal::checked_sub<size_t>(((((alias).target)).size()),static_cast<size_t>(1ULL))))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+size_t i = (_magic_value.value());
 {
+JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const namespace_ = TRY((((*this).find_namespace_in_scope(resolved_scope_id,((((((alias).target))[i])).name),false))));
+if ((!(((namespace_).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown namespace '{}'"sv),((((((alias).target))[i])).name)))),((((((alias).target))[i])).name_span)))));
+return {};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+(resolved_scope_id = (((namespace_.value())).template get<0>()));
+TRY((((alias_path).push(types::ResolvedNamespace(((((((alias).target))[i])).name),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())))));
 }
 
 }
 }
 
-((current_case_index++));
-}
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
+types::ScopeId const alias_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId,ErrorOr<void>>{
+auto __jakt_enum_value = (((((scope)->alias_scope)).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue((((scope)->alias_scope).value()));
+}
+else {
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_427; {
+types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,false,TRY((__jakt_format(Jakt::DeprecatedString("alias-scope({})"sv),((scope)->debug_name)))),false))));
+NonnullRefPtr<types::Scope> new_scope = TRY((((*this).get_scope(new_scope_id))));
+(((new_scope)->alias_path) = alias_path);
+TRY((((((TRY((((*this).get_scope(scope_id)))))->children)).push(new_scope_id))));
+__jakt_var_427 = new_scope_id; goto __jakt_label_402;
 
 }
+__jakt_label_402:; __jakt_var_427.release_value(); }));
+}
+}()))
+;
+TRY((((*this).find_and_import_name_from_scope((((((((alias).target)).last()).value())).name),(((((((alias).target)).last()).value())).name_span),((aliased_name).name),((aliased_name).span),resolved_scope_id,alias_scope_id,allow))));
+}
+return {};
+}
+
+ErrorOr<types::CheckedUnaryOperator> typechecker::Typechecker::typecheck_is_enum_variant(NonnullRefPtr<typename types::CheckedExpression> const checked_expr,NonnullRefPtr<typename parser::ParsedType> const inner,JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const bindings,types::ScopeId const scope_id) {
+{
+bool const old_ignore_errors = ((*this).ignore_errors);
+(((*this).ignore_errors) = true);
+types::TypeId const type_id = TRY((((*this).typecheck_typename(inner,scope_id,JaktInternal::OptionalNone()))));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
+types::CheckedUnaryOperator checked_op =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Is(type_id) } ;
+types::TypeId const expr_type_id = ((checked_expr)->type());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<types::CheckedUnaryOperator>>{
+auto&& __jakt_match_variant = *inner;
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& variant_name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+{
+if (((((*this).get_type(expr_type_id)))->index() == 24 /* Enum */)){
+types::EnumId const enum_id = ((((*this).get_type(expr_type_id)))->get<types::Type::Enum>()).value;
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+JaktInternal::Optional<types::CheckedEnumVariant> const variant = TRY((((*this).get_enum_variant(enum_,variant_name))));
+if (((variant).has_value())){
+JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>> const checked_enum_variant_bindings = TRY((((*this).typecheck_enum_variant_bindings((variant.value()),bindings,span))));
+(checked_op =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::IsEnumVariant((variant.value()),(checked_enum_variant_bindings.value()),expr_type_id) } );
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist on {}"sv),variant_name,TRY((((*this).type_name(type_id,false))))))),span))));
+return (checked_op);
+}
+
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),variant_name))),span))));
+return (checked_op);
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& variant_name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+{
+if (((((*this).get_type(expr_type_id)))->index() == 24 /* Enum */)){
+types::EnumId const enum_id = ((((*this).get_type(expr_type_id)))->get<types::Type::Enum>()).value;
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+JaktInternal::Optional<types::CheckedEnumVariant> const variant = TRY((((*this).get_enum_variant(enum_,variant_name))));
+if (((variant).has_value())){
+JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>> const checked_enum_variant_bindings = TRY((((*this).typecheck_enum_variant_bindings((variant.value()),bindings,span))));
+(checked_op =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::IsEnumVariant((variant.value()),(checked_enum_variant_bindings.value()),expr_type_id) } );
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist on {}"sv),variant_name,TRY((((*this).type_name(type_id,false))))))),span))));
+return (checked_op);
+}
+
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),variant_name))),span))));
+return (checked_op);
 }
 
-if ((is_value_match && (!(seen_catch_all)))){
-TRY((((*this).error(Jakt::DeprecatedString("match expression is not exhaustive, a value match must contain an irrefutable 'else' pattern"sv),span))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Match>(checked_expr,checked_cases,span,final_result_type.value_or_lazy_evaluated([&] { return types::void_type_id(); }),true))));
+return (checked_op);
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_module(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
+ErrorOr<bool> typechecker::Typechecker::add_var_to_scope(types::ScopeId const scope_id,DeprecatedString const name,types::VarId const var_id,utility::Span const span) {
 {
-TRY((((*this).typecheck_namespace_imports(parsed_namespace,scope_id))));
-TRY((((*this).typecheck_namespace_predecl(parsed_namespace,scope_id))));
-TRY((((*this).typecheck_namespace_aliases(parsed_namespace,scope_id,typechecker::ImportRestrictions(false,true,true,true,true,true)))));
-TRY((((*this).typecheck_namespace_fields(parsed_namespace,scope_id))));
-TRY((((*this).typecheck_namespace_constructors(parsed_namespace,scope_id))));
-TRY((((*this).typecheck_namespace_function_predecl(parsed_namespace,scope_id))));
-TRY((((*this).typecheck_namespace_aliases(parsed_namespace,scope_id,typechecker::ImportRestrictions(true,false,false,false,false,false)))));
-TRY((((*this).typecheck_namespace_default_fields(parsed_namespace,scope_id))));
-TRY((((*this).typecheck_namespace_declarations(parsed_namespace,scope_id))));
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::VarId> const existing_var = ((((scope)->vars)).get(name));
+if (((existing_var).has_value())){
+NonnullRefPtr<types::CheckedVariable> const variable_ = ((*this).get_variable((existing_var.value())));
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of variable ‘{}’"sv),name))),span,Jakt::DeprecatedString("previous definition here"sv),((variable_)->definition_span)))));
+}
+TRY((((((scope)->vars)).set(name,var_id))));
+TRY((((*this).set_owner_scope_if_needed(scope_id,var_id))));
+return (true);
 }
-return {};
 }
 
-ErrorOr<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> typechecker::Typechecker::find_all_implementations_of_trait(types::TypeId const type_id,types::TraitId const trait_id) {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>, ErrorOr<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>>>{
-auto&& __jakt_match_variant = *((*this).get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_427; {
-types::CheckedStruct const struct_ = ((*this).get_struct(struct_id));
-JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> implementations = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))));
+ErrorOr<bool> typechecker::Typechecker::add_comptime_binding_to_scope(types::ScopeId const scope_id,DeprecatedString const name,types::Value const value,utility::Span const span) {
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((((struct_).trait_implementations)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::Value> const existing_binding = ((((scope)->comptime_bindings)).get(name));
+if (((existing_binding).has_value())){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of comptime variable ‘{}’"sv),name))),span,Jakt::DeprecatedString("previous definition here"sv),(((existing_binding.value())).span)))));
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> ___trait_descriptor__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt_____trait_descriptor__ = ___trait_descriptor__;
-DeprecatedString const _ = ((jakt_____trait_descriptor__).template get<0>());
-JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_descriptor = ((jakt_____trait_descriptor__).template get<1>());
-
-if (((((trait_descriptor).template get<0>())).equals(trait_id))){
-TRY((((implementations).push(((trait_descriptor).template get<1>())))));
+TRY((((((scope)->comptime_bindings)).set(name,value))));
+return (true);
 }
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_match(NonnullRefPtr<typename parser::ParsedExpression> const expr,JaktInternal::DynamicArray<parser::ParsedMatchCase> const cases,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
+{
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+types::TypeId const subject_type_id = ((checked_expr)->type());
+NonnullRefPtr<typename types::Type> const type_to_match_on = ((*this).get_type(subject_type_id));
+JaktInternal::DynamicArray<types::CheckedMatchCase> checked_cases = (TRY((DynamicArray<types::CheckedMatchCase>::create_with({}))));
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+ScopeGuard __jakt_var_428([&] {
+{
+((((*this).generic_inferences)).restore(old_generic_inferences));
 }
-}
-
-__jakt_var_427 = implementations; goto __jakt_label_399;
 
+});
+JaktInternal::Optional<types::TypeId> final_result_type = JaktInternal::OptionalNone();
+if ((((type_hint).has_value()) && ((!((((type_hint.value())).equals(types::unknown_type_id())))) && (!(((((*this).get_type((type_hint.value()))))->index() == 18 /* TypeVariable */)))))){
+(final_result_type = type_hint);
 }
-__jakt_label_399:; __jakt_var_427.release_value(); }));
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_428; {
-types::CheckedStruct const struct_ = ((*this).get_struct(struct_id));
-JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> implementations = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))));
+if (((type_to_match_on)->index() == 20 /* GenericEnumInstance */)){
+types::EnumId const id = ((type_to_match_on)->get<types::Type::GenericEnumInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((type_to_match_on)->get<types::Type::GenericEnumInstance>()).args;
+types::CheckedEnum const enum_ = ((*this).get_enum(id));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((((struct_).trait_implementations)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((enum_).generic_parameters)).size()))});
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> ___trait_descriptor__ = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt_____trait_descriptor__ = ___trait_descriptor__;
-DeprecatedString const _ = ((jakt_____trait_descriptor__).template get<0>());
-JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_descriptor = ((jakt_____trait_descriptor__).template get<1>());
-
-if (((((trait_descriptor).template get<0>())).equals(trait_id))){
-TRY((((implementations).push(((trait_descriptor).template get<1>())))));
+DeprecatedString const generic = TRY((((((((((enum_).generic_parameters))[i])).type_id)).to_string())));
+DeprecatedString const argument_type = TRY((((((args)[i])).to_string())));
+if ((generic != argument_type)){
+TRY((((((*this).generic_inferences)).set(generic,argument_type))));
 }
 }
 
 }
 }
 
-__jakt_var_428 = implementations; goto __jakt_label_400;
-
 }
-__jakt_label_400:; __jakt_var_428.release_value(); }));
-};/*case end*/
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *type_to_match_on;
+switch(__jakt_match_variant.index()) {
 case 24: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
 types::EnumId const& enum_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_429; {
+{
 types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> implementations = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))));
+bool seen_catch_all = false;
+bool expanded_catch_all = false;
+JaktInternal::Optional<utility::Span> catch_all_span = JaktInternal::OptionalNone();
+JaktInternal::Set<DeprecatedString> covered_variants = (TRY((Set<DeprecatedString>::create_with_values({}))));
+size_t const case_count = ((cases).size());
+size_t current_case_index = static_cast<size_t>(0ULL);
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((((enum_).trait_implementations)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedMatchCase> _magic = ((cases).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMatchCase> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> ___trait_descriptor__ = (_magic_value.value());
+parser::ParsedMatchCase case_ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt_____trait_descriptor__ = ___trait_descriptor__;
-DeprecatedString const _ = ((jakt_____trait_descriptor__).template get<0>());
-JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_descriptor = ((jakt_____trait_descriptor__).template get<1>());
-
-if (((((trait_descriptor).template get<0>())).equals(trait_id))){
-TRY((((implementations).push(((trait_descriptor).template get<1>())))));
-}
+{
+JaktInternal::ArrayIterator<parser::ParsedMatchPattern> _magic = ((((case_).patterns)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMatchPattern> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
+parser::ParsedMatchPattern pattern = (_magic_value.value());
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = pattern;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::EnumVariant>();JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const& variant_names = __jakt_match_value.variant_names;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
+utility::Span const& arguments_span = __jakt_match_value.arguments_span;
+{
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> variant_names_ = variant_names;
+if ((((variant_names_).size()) == static_cast<size_t>(1ULL))){
+JaktInternal::Tuple<DeprecatedString,utility::Span> const temp = ((variant_names_)[static_cast<i64>(0LL)]);
+(variant_names_ = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({(Tuple{((enum_).name), ((((variant_names_)[static_cast<i64>(0LL)])).template get<1>())}), temp})))));
 }
+if (((variant_names_).is_empty())){
+return JaktInternal::LoopContinue{};
 }
-
-__jakt_var_429 = implementations; goto __jakt_label_401;
-
+if ((((((variant_names_)[static_cast<i64>(0LL)])).template get<0>()) != ((enum_).name))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case '{}' does not match enum '{}'"sv),((((variant_names_)[static_cast<i64>(0LL)])).template get<0>()),((enum_).name)))),((((variant_names_)[static_cast<i64>(0LL)])).template get<1>())))));
+return JaktInternal::LoopContinue{};
 }
-__jakt_label_401:; __jakt_var_429.release_value(); }));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_430; {
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> implementations = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))));
+size_t i = static_cast<size_t>(0ULL);
+JaktInternal::Optional<types::CheckedEnumVariant> matched_variant = JaktInternal::OptionalNone();
+JaktInternal::Optional<size_t> variant_index = JaktInternal::OptionalNone();
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((((enum_).trait_implementations)).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> ___trait_descriptor__ = (_magic_value.value());
+types::CheckedEnumVariant v = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt_____trait_descriptor__ = ___trait_descriptor__;
-DeprecatedString const _ = ((jakt_____trait_descriptor__).template get<0>());
-JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_descriptor = ((jakt_____trait_descriptor__).template get<1>());
-
-if (((((trait_descriptor).template get<0>())).equals(trait_id))){
-TRY((((implementations).push(((trait_descriptor).template get<1>())))));
+if ((((v).name()) == ((((variant_names_)[static_cast<i64>(1LL)])).template get<0>()))){
+(matched_variant = v);
+(variant_index = i);
 }
+((i++));
 }
 
 }
 }
 
-__jakt_var_430 = implementations; goto __jakt_label_402;
-
-}
-__jakt_label_402:; __jakt_var_430.release_value(); }));
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
-types::TraitId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_431; {
-if (((id).equals(trait_id))){
-return ((TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({(TRY((DynamicArray<types::TypeId>::create_with({}))))})))));
+if ((!(((matched_variant).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum '{}' does not contain a variant named '{}'"sv),((enum_).name),((((variant_names_)[static_cast<i64>(1LL)])).template get<0>())))),((case_).marker_span)))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Match>(checked_expr,(TRY((DynamicArray<types::CheckedMatchCase>::create_with({})))),span,types::unknown_type_id(),false))));
 }
-__jakt_var_431 = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({})))); goto __jakt_label_403;
+JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>> const covered_name_checked_match_case_result_type_ = TRY((((*this).typecheck_match_variant(case_,subject_type_id,(variant_index.value()),final_result_type,(matched_variant.value()),variant_arguments,((pattern).defaults()),arguments_span,scope_id,safety_mode))));
+JaktInternal::Optional<DeprecatedString> const covered_name = ((covered_name_checked_match_case_result_type_).template get<0>());
+types::CheckedMatchCase const checked_match_case = ((covered_name_checked_match_case_result_type_).template get<1>());
+JaktInternal::Optional<types::TypeId> const result_type = ((covered_name_checked_match_case_result_type_).template get<2>());
 
+if (((covered_name).has_value())){
+TRY((((covered_variants).add((covered_name.value())))));
 }
-__jakt_label_403:; __jakt_var_431.release_value(); }));
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_432; {
-if ((!(((id).equals(trait_id))))){
-return ((TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({})))));
-}
-__jakt_var_432 = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({args})))); goto __jakt_label_404;
-
+(final_result_type = result_type);
+TRY((((checked_cases).push(checked_match_case))));
 }
-__jakt_label_404:; __jakt_var_432.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue((TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({})))));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<types::TypeId> typechecker::Typechecker::substitute_typevars_in_type(types::TypeId const type_id,types::GenericInferences const generic_inferences) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::CatchAll>();JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
+utility::Span const& arguments_span = __jakt_match_value.arguments_span;
 {
-return (TRY((((((*this).program))->substitute_typevars_in_type(type_id,generic_inferences,((*this).current_module_id))))));
+if ((current_case_index != (JaktInternal::checked_sub<size_t>(case_count,static_cast<size_t>(1ULL))))){
+TRY((((*this).error(Jakt::DeprecatedString("Match else case is only allowed as the last case"sv),((case_).marker_span)))));
+}
+if (seen_catch_all){
+TRY((((*this).error(Jakt::DeprecatedString("Multiple catch-all cases in match are not allowed"sv),((case_).marker_span)))));
 }
+else {
+(seen_catch_all = true);
 }
 
-ErrorOr<types::StructId> typechecker::Typechecker::find_struct_in_prelude(DeprecatedString const name) const {
+if ((((variant_arguments).size()) > static_cast<size_t>(0ULL))){
+size_t variant_index = static_cast<size_t>(0ULL);
 {
-return (TRY((((((*this).program))->find_struct_in_prelude(name)))));
-}
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-ErrorOr<void> typechecker::Typechecker::typecheck_module_import(parser::ParsedModuleImport const import_,types::ScopeId const scope_id) {
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> const module_names_and_spans = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((import_).module_name);
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Literal>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>>((TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({(Tuple{name, span})}))))));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Comptime>();NonnullRefPtr<typename parser::ParsedExpression> const& expression = __jakt_match_value.expression;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>> __jakt_var_433; {
-NonnullRefPtr<interpreter::Interpreter> interpreter = TRY((((*this).interpreter())));
-NonnullRefPtr<interpreter::InterpreterScope> eval_scope = TRY((interpreter::InterpreterScope::from_runtime_scope(scope_id,((*this).program),JaktInternal::OptionalNone())));
-types::ScopeId const exec_scope = TRY((((*this).create_scope(scope_id,true,Jakt::DeprecatedString("comptime-import"sv),true))));
-interpreter::StatementResult const result = TRY((((interpreter)->execute_expression(TRY((((*this).typecheck_expression(expression,exec_scope, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone())))),eval_scope))));
-__jakt_var_433 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>, ErrorOr<void>>{
-auto&& __jakt_match_variant = result;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_434; {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((expression)->span())))));
-__jakt_var_434 = JaktInternal::OptionalNone(); goto __jakt_label_406;
+if ((!(((covered_variants).contains(((variant).name())))))){
+(expanded_catch_all = true);
+JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>> const covered_name_checked_match_case_result_type_ = TRY((((*this).typecheck_match_variant(case_,subject_type_id,variant_index,final_result_type,variant,variant_arguments,((pattern).defaults()),arguments_span,scope_id,safety_mode))));
+JaktInternal::Optional<DeprecatedString> const covered_name = ((covered_name_checked_match_case_result_type_).template get<0>());
+types::CheckedMatchCase const checked_match_case = ((covered_name_checked_match_case_result_type_).template get<1>());
+JaktInternal::Optional<types::TypeId> const result_type = ((covered_name_checked_match_case_result_type_).template get<2>());
 
+if (((covered_name).has_value())){
+TRY((((covered_variants).add((covered_name.value())))));
 }
-__jakt_label_406:; __jakt_var_434; }));
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_435; {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((expression)->span())))));
-__jakt_var_435 = JaktInternal::OptionalNone(); goto __jakt_label_407;
-
+(final_result_type = result_type);
+TRY((((checked_cases).push(checked_match_case))));
 }
-__jakt_label_407:; __jakt_var_435; }));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_436; {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((expression)->span())))));
-__jakt_var_436 = JaktInternal::OptionalNone(); goto __jakt_label_408;
-
+((variant_index++));
 }
-__jakt_label_408:; __jakt_var_436; }));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_437; {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((expression)->span())))));
-__jakt_var_437 = JaktInternal::OptionalNone(); goto __jakt_label_409;
 
 }
-__jakt_label_409:; __jakt_var_437; }));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
-types::Value const& error = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_438; {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),TRY((__jakt_format(Jakt::DeprecatedString("this expression threw an error: {}"sv),error))),((expression)->span())))));
-__jakt_var_438 = JaktInternal::OptionalNone(); goto __jakt_label_410;
-
 }
-__jakt_label_410:; __jakt_var_438; }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& string = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>>((TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({(Tuple{string, ((value).span)})}))))));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>> __jakt_var_439; {
-if (((values).is_empty())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an empty array"sv),((expression)->span())))));
+
 }
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> result = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({}))));
+else {
+types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),Jakt::DeprecatedString("catch-all"sv),true))));
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::Value> _magic = ((values).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((pattern).defaults())).iterator());
 for (;;){
-JaktInternal::Optional<types::Value> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::Value value = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
 {
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((value).impl);
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& string = __jakt_match_value.value;
-return (TRY((((result).push((Tuple{string, ((value).span)})))))), JaktInternal::ExplicitValue<void>();
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
+DeprecatedString const _ = ((jakt_____default___).template get<0>());
+parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
+
+NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
+TRY((((defaults).push(checked_var_decl))));
+}
+
+}
+}
+
+JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
+types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
+JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
+
+(final_result_type = result_type);
+types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::CatchAll(defaults,false,checked_body,((case_).marker_span)) } ;
+TRY((((checked_cases).push(checked_match_case))));
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((value).span),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((value).span)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
@@ -2616,2059 +2506,2127 @@ return JaktInternal::ExplicitValue<void>();
 }
 }
 
-__jakt_var_439 = static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>>(result); goto __jakt_label_411;
-
-}
-__jakt_label_411:; __jakt_var_439.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_440; {
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to a non-string value"sv),((expression)->span())))));
-__jakt_var_440 = JaktInternal::OptionalNone(); goto __jakt_label_412;
-
+((current_case_index++));
 }
-__jakt_label_412:; __jakt_var_440; }));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)); goto __jakt_label_405;
 
 }
-__jakt_label_405:; __jakt_var_433.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-if ((!(((module_names_and_spans).has_value())))){
-return {};
 }
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>> module_name_and_span = JaktInternal::OptionalNone();
-JaktInternal::DynamicArray<DeprecatedString> names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+
+JaktInternal::DynamicArray<DeprecatedString> enum_variant_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+JaktInternal::DynamicArray<DeprecatedString> missing_variants = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span>> _magic = (((module_names_and_spans.value())).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span> name_and_span = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-TRY((((names).push(((name_and_span).template get<0>())))));
-JaktInternal::Optional<types::LoadedModule> maybe_loaded_module = ((((*this).program))->get_loaded_module(((name_and_span).template get<0>())));
-if ((!(((maybe_loaded_module).has_value())))){
-JaktInternal::Optional<jakt__path::Path> const maybe_file_name = TRY((((((*this).compiler))->search_for_path(((name_and_span).template get<0>())))));
-jakt__path::Path const file_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<jakt__path::Path,ErrorOr<void>>{
-auto __jakt_enum_value = (((maybe_file_name).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue((maybe_file_name.value()));
-}
-else {
-return JaktInternal::ExplicitValue(TRY((((TRY((((TRY((((TRY((((*this).get_root_path())))).parent())))).join(((name_and_span).template get<0>())))))).replace_extension(Jakt::DeprecatedString("jakt"sv))))));
+TRY((((enum_variant_names).push(((variant).name())))));
 }
-}()))
-;
-if (File::exists(((file_name).to_string()))){
-(module_name_and_span = name_and_span);
-break;
+
 }
 }
-else {
-(module_name_and_span = name_and_span);
+
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((enum_variant_names).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
 break;
 }
-
+DeprecatedString variant = (_magic_value.value());
+{
+if ((!(((covered_variants).contains(variant))))){
+TRY((((missing_variants).push(variant))));
+}
 }
 
 }
 }
 
-if ((!(((module_name_and_span).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("No module in module set {{{}}} was found"sv),utility::join(names,Jakt::DeprecatedString(", "sv))))),((((import_).module_name)).span())))));
-return {};
+if ((((missing_variants).size()) > static_cast<size_t>(0ULL))){
+if ((!(seen_catch_all))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match expression is not exhaustive, missing variants are: {}"sv),utility::join(missing_variants,Jakt::DeprecatedString(", "sv))))),span))));
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span> const module_name_module_span_ = (module_name_and_span.value());
-DeprecatedString const module_name = ((module_name_module_span_).template get<0>());
-utility::Span const module_span = ((module_name_module_span_).template get<1>());
-
-DeprecatedString const sanitized_module_name = ((module_name).replace(Jakt::DeprecatedString(":"sv),Jakt::DeprecatedString("_"sv)));
-types::ModuleId imported_module_id = types::ModuleId(static_cast<size_t>(0ULL));
-JaktInternal::Optional<types::LoadedModule> maybe_loaded_module = ((((*this).program))->get_loaded_module(sanitized_module_name));
-if ((!(((maybe_loaded_module).has_value())))){
-JaktInternal::Optional<jakt__path::Path> const maybe_file_name = TRY((((((*this).compiler))->search_for_path(module_name))));
-jakt__path::Path const file_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<jakt__path::Path,ErrorOr<void>>{
-auto __jakt_enum_value = (((maybe_file_name).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue((maybe_file_name.value()));
 }
-else {
-return JaktInternal::ExplicitValue(TRY((((TRY((((TRY((((TRY((((*this).get_root_path())))).parent())))).join(module_name))))).replace_extension(Jakt::DeprecatedString("jakt"sv))))));
+else if ((seen_catch_all && (!(expanded_catch_all)))){
+TRY((((*this).error(Jakt::DeprecatedString("All variants are covered, but an irrefutable pattern is also present"sv),span))));
 }
-}()))
-;
-utility::FileId const file_id = TRY((((((*this).compiler))->get_file_id_or_register(file_name))));
-JaktInternal::Optional<parser::ParsedNamespace> const parsed_namespace = TRY((((*this).lex_and_parse_file_contents(file_id))));
-if ((!(((parsed_namespace).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Module '{}' not found"sv),module_name))),module_span))));
-return {};
-}
-types::ModuleId const original_current_module_id = ((*this).current_module_id);
-(imported_module_id = TRY((((*this).create_module(sanitized_module_name,false,((file_name).to_string()))))));
-TRY((((((*this).program))->set_loaded_module(sanitized_module_name,types::LoadedModule(imported_module_id,file_id)))));
-(((*this).current_module_id) = imported_module_id);
-types::ScopeId const imported_scope_id = TRY((((*this).create_scope(((*this).root_scope_id()),false,TRY((__jakt_format(Jakt::DeprecatedString("module({})"sv),sanitized_module_name))),false))));
-NonnullRefPtr<types::Scope> imported_scope = TRY((((*this).get_scope(imported_scope_id))));
-(((imported_scope)->namespace_name) = sanitized_module_name);
-TRY((((*this).typecheck_module((parsed_namespace.value()),imported_scope_id))));
-(((*this).current_module_id) = original_current_module_id);
-}
-else {
-(imported_module_id = (((maybe_loaded_module.value())).module_id));
-}
-
-JaktInternal::DynamicArray<types::ModuleId> current_module_imports = ((((*this).current_module()))->imports);
-TRY((((current_module_imports).push(imported_module_id))));
-if (((((import_).import_list)).is_empty())){
-JaktInternal::Dictionary<DeprecatedString,types::ModuleId> scope_imports = ((TRY((((*this).get_scope(scope_id)))))->imports);
-DeprecatedString import_name = module_name;
-if (((((import_).alias_name)).has_value())){
-(import_name = (((((import_).alias_name).value())).literal_name()));
-}
-TRY((((scope_imports).set(import_name,imported_module_id))));
 }
-else if (((((import_).import_list)).index() == 1 /* All */)){
-NonnullRefPtr<types::Scope> const import_scope = TRY((((*this).get_scope(types::ScopeId(imported_module_id,static_cast<size_t>(0ULL))))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::VarId> _magic = ((((import_scope)->vars)).iterator());
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+bool seen_catch_all = false;
+bool expanded_catch_all = false;
+JaktInternal::Optional<utility::Span> catch_all_span = JaktInternal::OptionalNone();
+JaktInternal::Set<DeprecatedString> covered_variants = (TRY((Set<DeprecatedString>::create_with_values({}))));
+size_t const case_count = ((cases).size());
+size_t current_case_index = static_cast<size_t>(0ULL);
+{
+JaktInternal::ArrayIterator<parser::ParsedMatchCase> _magic = ((cases).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::VarId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMatchCase> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::VarId> name__var_id__ = (_magic_value.value());
+parser::ParsedMatchCase case_ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::VarId> const jakt__name__var_id__ = name__var_id__;
-DeprecatedString const name = ((jakt__name__var_id__).template get<0>());
-types::VarId const var_id = ((jakt__name__var_id__).template get<1>());
-
-TRY((((*this).add_var_to_scope(scope_id,name,var_id,((((import_).module_name)).span())))));
-}
-
-}
-}
-
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::Value> _magic = ((((import_scope)->comptime_bindings)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedMatchPattern> _magic = ((((case_).patterns)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::Value>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMatchPattern> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::Value> name__value__ = (_magic_value.value());
+parser::ParsedMatchPattern pattern = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::Value> const jakt__name__value__ = name__value__;
-DeprecatedString const name = ((jakt__name__value__).template get<0>());
-types::Value const value = ((jakt__name__value__).template get<1>());
-
-TRY((((*this).add_comptime_binding_to_scope(scope_id,name,value,((((import_).module_name)).span())))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = pattern;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::EnumVariant>();JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const& variant_names = __jakt_match_value.variant_names;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
+utility::Span const& arguments_span = __jakt_match_value.arguments_span;
+{
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> variant_names_ = variant_names;
+if ((((variant_names_).size()) == static_cast<size_t>(1ULL))){
+JaktInternal::Tuple<DeprecatedString,utility::Span> const temp = ((variant_names_)[static_cast<i64>(0LL)]);
+(variant_names_ = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({(Tuple{((enum_).name), ((((variant_names_)[static_cast<i64>(0LL)])).template get<1>())}), temp})))));
 }
-
+if (((variant_names_).is_empty())){
+return JaktInternal::LoopContinue{};
 }
+if ((((((variant_names_)[static_cast<i64>(0LL)])).template get<0>()) != ((enum_).name))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case '{}' does not match enum '{}'"sv),((((variant_names_)[static_cast<i64>(0LL)])).template get<0>()),((enum_).name)))),((((variant_names_)[static_cast<i64>(0LL)])).template get<1>())))));
+return JaktInternal::LoopContinue{};
 }
-
+size_t i = static_cast<size_t>(0ULL);
+JaktInternal::Optional<types::CheckedEnumVariant> matched_variant = JaktInternal::OptionalNone();
+JaktInternal::Optional<size_t> variant_index = JaktInternal::OptionalNone();
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((import_scope)->structs)).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::StructId> name__struct_id__ = (_magic_value.value());
+types::CheckedEnumVariant v = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt__name__struct_id__ = name__struct_id__;
-DeprecatedString const name = ((jakt__name__struct_id__).template get<0>());
-types::StructId const struct_id = ((jakt__name__struct_id__).template get<1>());
+if ((((v).name()) == ((((variant_names_)[static_cast<i64>(1LL)])).template get<0>()))){
+(matched_variant = v);
+(variant_index = i);
+}
+((i++));
+}
 
-TRY((((*this).add_struct_to_scope(scope_id,name,struct_id,((((import_).module_name)).span())))));
 }
+}
+
+if ((!(((matched_variant).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum '{}' does not contain a variant named '{}'"sv),((enum_).name),((((variant_names_)[static_cast<i64>(1LL)])).template get<0>())))),((case_).marker_span)))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Match>(checked_expr,(TRY((DynamicArray<types::CheckedMatchCase>::create_with({})))),span,types::unknown_type_id(),false))));
+}
+JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>> const covered_name_checked_match_case_result_type_ = TRY((((*this).typecheck_match_variant(case_,subject_type_id,(variant_index.value()),final_result_type,(matched_variant.value()),variant_arguments,((pattern).defaults()),arguments_span,scope_id,safety_mode))));
+JaktInternal::Optional<DeprecatedString> const covered_name = ((covered_name_checked_match_case_result_type_).template get<0>());
+types::CheckedMatchCase const checked_match_case = ((covered_name_checked_match_case_result_type_).template get<1>());
+JaktInternal::Optional<types::TypeId> const result_type = ((covered_name_checked_match_case_result_type_).template get<2>());
 
+if (((covered_name).has_value())){
+TRY((((covered_variants).add((covered_name.value())))));
+}
+(final_result_type = result_type);
+TRY((((checked_cases).push(checked_match_case))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::CatchAll>();JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
+utility::Span const& arguments_span = __jakt_match_value.arguments_span;
+{
+if ((current_case_index != (JaktInternal::checked_sub<size_t>(case_count,static_cast<size_t>(1ULL))))){
+TRY((((*this).error(Jakt::DeprecatedString("Match else case is only allowed as the last case"sv),((case_).marker_span)))));
 }
+if (seen_catch_all){
+TRY((((*this).error(Jakt::DeprecatedString("Multiple catch-all cases in match are not allowed"sv),((case_).marker_span)))));
+}
+else {
+(seen_catch_all = true);
 }
 
+if ((((variant_arguments).size()) > static_cast<size_t>(0ULL))){
+size_t variant_index = static_cast<size_t>(0ULL);
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((import_scope)->functions)).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> name__overload_set__ = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt__name__overload_set__ = name__overload_set__;
-DeprecatedString const name = ((jakt__name__overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt__name__overload_set__).template get<1>());
+if ((!(((covered_variants).contains(((variant).name())))))){
+(expanded_catch_all = true);
+JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>> const covered_name_checked_match_case_result_type_ = TRY((((*this).typecheck_match_variant(case_,subject_type_id,variant_index,final_result_type,variant,variant_arguments,((pattern).defaults()),arguments_span,scope_id,safety_mode))));
+JaktInternal::Optional<DeprecatedString> const covered_name = ((covered_name_checked_match_case_result_type_).template get<0>());
+types::CheckedMatchCase const checked_match_case = ((covered_name_checked_match_case_result_type_).template get<1>());
+JaktInternal::Optional<types::TypeId> const result_type = ((covered_name_checked_match_case_result_type_).template get<2>());
 
-TRY((((*this).add_function_to_scope(scope_id,name,overload_set,((((import_).module_name)).span())))));
+if (((covered_name).has_value())){
+TRY((((covered_variants).add((covered_name.value())))));
+}
+(final_result_type = result_type);
+TRY((((checked_cases).push(checked_match_case))));
+}
+((variant_index++));
 }
 
 }
 }
 
+}
+else {
+types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),Jakt::DeprecatedString("catch-all"sv),true))));
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((import_scope)->enums)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((pattern).defaults())).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::EnumId> name__enum_id__ = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt__name__enum_id__ = name__enum_id__;
-DeprecatedString const name = ((jakt__name__enum_id__).template get<0>());
-types::EnumId const enum_id = ((jakt__name__enum_id__).template get<1>());
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
+DeprecatedString const _ = ((jakt_____default___).template get<0>());
+parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
 
-TRY((((*this).add_enum_to_scope(scope_id,name,enum_id,((((import_).module_name)).span())))));
+NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
+TRY((((defaults).push(checked_var_decl))));
 }
 
 }
 }
 
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::TypeId> _magic = ((((import_scope)->types)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::TypeId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
+types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
+JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
+
+(final_result_type = result_type);
+types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::CatchAll(defaults,false,checked_body,((case_).marker_span)) } ;
+TRY((((checked_cases).push(checked_match_case))));
 }
-JaktInternal::Tuple<DeprecatedString,types::TypeId> name__type_id__ = (_magic_value.value());
+
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-JaktInternal::Tuple<DeprecatedString,types::TypeId> const jakt__name__type_id__ = name__type_id__;
-DeprecatedString const name = ((jakt__name__type_id__).template get<0>());
-types::TypeId const type_id = ((jakt__name__type_id__).template get<1>());
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+}
 
-TRY((((*this).add_type_to_scope(scope_id,name,type_id,((((import_).module_name)).span())))));
+}
+}
+
+((current_case_index++));
 }
 
 }
 }
 
+JaktInternal::DynamicArray<DeprecatedString> enum_variant_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+JaktInternal::DynamicArray<DeprecatedString> missing_variants = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::TraitId> _magic = ((((import_scope)->traits)).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::TraitId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::TraitId> name__trait_id__ = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::TraitId> const jakt__name__trait_id__ = name__trait_id__;
-DeprecatedString const name = ((jakt__name__trait_id__).template get<0>());
-types::TraitId const trait_id = ((jakt__name__trait_id__).template get<1>());
-
-TRY((((*this).add_trait_to_scope(scope_id,name,trait_id,((((import_).module_name)).span())))));
+TRY((((enum_variant_names).push(((variant).name())))));
 }
 
 }
 }
 
-}
-else if (((((import_).import_list)).index() == 0 /* List */)){
-JaktInternal::DynamicArray<parser::ImportName> const names = ((((import_).import_list)).get<parser::ImportList::List>()).value;
-types::ScopeId const import_scope_id = types::ScopeId(imported_module_id,static_cast<size_t>(0ULL));
 {
-JaktInternal::ArrayIterator<parser::ImportName> _magic = ((names).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((enum_variant_names).iterator());
 for (;;){
-JaktInternal::Optional<parser::ImportName> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ImportName imported_name = (_magic_value.value());
+DeprecatedString variant = (_magic_value.value());
 {
-bool const found = TRY((((*this).find_and_import_name_from_scope(((imported_name).literal_name()),((imported_name).span()),((imported_name).literal_name()),((imported_name).span()),import_scope_id,scope_id,typechecker::ImportRestrictions::all()))));
-if ((!(found))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Imported name '{}' not found in module '{}'"sv),((imported_name).literal_name()),module_name))),((imported_name).span())))));
+if ((!(((covered_variants).contains(variant))))){
+TRY((((missing_variants).push(variant))));
 }
 }
 
 }
 }
 
+if ((((missing_variants).size()) > static_cast<size_t>(0ULL))){
+if ((!(seen_catch_all))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match expression is not exhaustive, missing variants are: {}"sv),utility::join(missing_variants,Jakt::DeprecatedString(", "sv))))),span))));
 }
 }
-return {};
+else if ((seen_catch_all && (!(expanded_catch_all)))){
+TRY((((*this).error(Jakt::DeprecatedString("All variants are covered, but an irrefutable pattern is also present"sv),span))));
 }
-
-ErrorOr<types::TypeId> typechecker::Typechecker::typecheck_binary_operation(NonnullRefPtr<typename types::CheckedExpression> const checked_lhs,parser::BinaryOperator const op,NonnullRefPtr<typename types::CheckedExpression> const checked_rhs,types::ScopeId const scope_id,utility::Span const span) {
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 0: {
 {
-types::TypeId const lhs_type_id = ((checked_lhs)->type());
-types::TypeId const rhs_type_id = ((checked_rhs)->type());
-utility::Span const lhs_span = ((checked_lhs)->span());
-utility::Span const rhs_span = ((checked_rhs)->span());
-types::TypeId type_id = ((checked_lhs)->type());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<types::TypeId>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 20: {
-{
-if (((op).index() == 32 /* NoneCoalescingAssign */)){
-if (((checked_lhs)->index() == 24 /* Var */)){
-NonnullRefPtr<types::CheckedVariable> const var = ((checked_lhs)->get<types::CheckedExpression::Var>()).var;
-utility::Span const span = ((checked_lhs)->get<types::CheckedExpression::Var>()).span;
-if ((!(((var)->is_mutable)))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("left-hand side of ??= must be a mutable variable"sv),span,Jakt::DeprecatedString("This variable isn't marked as mutable"sv),((var)->definition_span)))));
-return (types::unknown_type_id());
-}
+TRY((((*this).error(Jakt::DeprecatedString("Can't match on 'void' type"sv),((checked_expr)->span())))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("left-hand side of ??= must be a mutable variable"sv),span))));
-return (types::unknown_type_id());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+bool is_enum_match = false;
+bool is_value_match = false;
+bool seen_catch_all = false;
+bool all_variants_constant = true;
+size_t const case_count = ((cases).size());
+size_t current_case_index = static_cast<size_t>(0ULL);
+{
+JaktInternal::ArrayIterator<parser::ParsedMatchCase> _magic = ((cases).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMatchCase> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
+parser::ParsedMatchCase case_ = (_magic_value.value());
+{
+{
+JaktInternal::ArrayIterator<parser::ParsedMatchPattern> _magic = ((((case_).patterns)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMatchPattern> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if (((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))))))){
-if (((lhs_type_id).equals(rhs_type_id))){
-return (lhs_type_id);
+parser::ParsedMatchPattern pattern = (_magic_value.value());
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = pattern;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::EnumVariant>();JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> const& variant_names = __jakt_match_value.variant_names;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
+utility::Span const& arguments_span = __jakt_match_value.arguments_span;
+{
+if (is_value_match){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot have an enum match case in a match expression containing value matches"sv),((case_).marker_span)))));
 }
-types::TypeId const inner_type_id = ((args)[static_cast<i64>(0LL)]);
-if (((inner_type_id).equals(rhs_type_id))){
-return (inner_type_id);
+if ((((variant_names).size()) == static_cast<size_t>(0ULL))){
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_match - else - EnumVariant - variant_names.size() == 0"sv)))));
 }
+(is_enum_match = true);
+types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),TRY((__jakt_format(Jakt::DeprecatedString("catch-enum-variant({})"sv),variant_names))),true))));
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((pattern).defaults())).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,Jakt::DeprecatedString("Left side of ?? must be an Optional but isn't"sv),lhs_span))));
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
+DeprecatedString const _ = ((jakt_____default___).template get<0>());
+parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
+
+NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
+TRY((((defaults).push(checked_var_decl))));
 }
 
 }
-else {
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,Jakt::DeprecatedString("Left side of ?? must be an Optional but isn't"sv),lhs_span))));
 }
 
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (lhs_type_id);
+JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
+types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
+JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
+
+(final_result_type = result_type);
+types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::EnumVariant(defaults,(((((variant_names).last()).value())).template get<0>()),variant_arguments,subject_type_id,static_cast<size_t>(0ULL),new_scope_id,checked_body,((case_).marker_span)) } ;
+TRY((((checked_cases).push(checked_match_case))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 32: {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedMatchPattern::CatchAll>();JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& variant_arguments = __jakt_match_value.variant_arguments;
 {
-if (((op).index() == 32 /* NoneCoalescingAssign */)){
-if (((checked_lhs)->index() == 24 /* Var */)){
-NonnullRefPtr<types::CheckedVariable> const var = ((checked_lhs)->get<types::CheckedExpression::Var>()).var;
-utility::Span const span = ((checked_lhs)->get<types::CheckedExpression::Var>()).span;
-if ((!(((var)->is_mutable)))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("left-hand side of ??= must be a mutable variable"sv),span,Jakt::DeprecatedString("This variable isn't marked as mutable"sv),((var)->definition_span)))));
-return (types::unknown_type_id());
+if ((current_case_index != (JaktInternal::checked_sub<size_t>(case_count,static_cast<size_t>(1ULL))))){
+TRY((((*this).error(Jakt::DeprecatedString("Match else case is only allowed as the last case"sv),((case_).marker_span)))));
 }
+if (seen_catch_all){
+TRY((((*this).error(Jakt::DeprecatedString("Multiple catch-all cases in match are not allowed"sv),((case_).marker_span)))));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("left-hand side of ??= must be a mutable variable"sv),span))));
-return (types::unknown_type_id());
+(seen_catch_all = true);
 }
 
+if ((((variant_arguments).size()) != static_cast<size_t>(0ULL))){
+bool const old_ignore_errors = ((*this).ignore_errors);
+(((*this).ignore_errors) = false);
+TRY((((*this).error(Jakt::DeprecatedString("Bindings aren't allowed in a generic else"sv),((case_).marker_span)))));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
 }
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if (((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))))))){
-if (((lhs_type_id).equals(rhs_type_id))){
-return (lhs_type_id);
-}
-types::TypeId const inner_type_id = ((args)[static_cast<i64>(0LL)]);
-if (((inner_type_id).equals(rhs_type_id))){
-return (inner_type_id);
-}
+types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),Jakt::DeprecatedString("catch-all"sv),true))));
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((((pattern).defaults())).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,Jakt::DeprecatedString("Left side of ?? must be an Optional but isn't"sv),lhs_span))));
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
+DeprecatedString const _ = ((jakt_____default___).template get<0>());
+parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
+
+NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
+TRY((((defaults).push(checked_var_decl))));
 }
 
 }
-else {
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,Jakt::DeprecatedString("Left side of ?? must be an Optional but isn't"sv),lhs_span))));
 }
 
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (lhs_type_id);
+JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
+types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
+JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
+
+(final_result_type = result_type);
+types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::CatchAll(defaults,(((variant_arguments).size()) != static_cast<size_t>(0ULL)),checked_body,((case_).marker_span)) } ;
+TRY((((checked_cases).push(checked_match_case))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 5: {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchPattern::Expression>();
+NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.value;
 {
-if ((!(((lhs_type_id).equals(rhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+if (is_enum_match){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot have a value match case in a match expression containing enum matches"sv),((case_).marker_span)))));
 }
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
+(is_value_match = true);
+JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const new_condition_new_then_block_new_else_statement_ = TRY((((*this).expand_context_for_bindings(expr,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),span))));
+NonnullRefPtr<typename parser::ParsedExpression> const new_condition = ((new_condition_new_then_block_new_else_statement_).template get<0>());
+JaktInternal::Optional<parser::ParsedBlock> const new_then_block = ((new_condition_new_then_block_new_else_statement_).template get<1>());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const new_else_statement = ((new_condition_new_then_block_new_else_statement_).template get<2>());
+
+NonnullRefPtr<typename types::CheckedExpression> const checked_expression = TRY((((*this).typecheck_expression_and_dereference_if_needed(new_condition,scope_id,safety_mode,static_cast<JaktInternal::Optional<types::TypeId>>(subject_type_id),span))));
+if ((!(((((checked_expression)->to_number_constant(((*this).program)))).has_value())))){
+(all_variants_constant = false);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 6: {
-{
-if ((!(((lhs_type_id).equals(rhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+types::TypeId expression_type = ((checked_expression)->type());
+if (((checked_expression)->index() == 9 /* Range */)){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const from = ((checked_expression)->get<types::CheckedExpression::Range>()).from;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const to = ((checked_expression)->get<types::CheckedExpression::Range>()).to;
+if ((((from).has_value()) || ((to).has_value()))){
+if (((from).has_value())){
+(expression_type = (((from.value()))->type()));
 }
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
+else if (((to).has_value())){
+(expression_type = (((to.value()))->type()));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 7: {
-{
-if ((!(((lhs_type_id).equals(rhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("There has to be at least a 'from', or a 'to' in a range expression"sv),((expr)->span())))));
+return JaktInternal::LoopContinue{};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 8: {
-{
-if ((!(((lhs_type_id).equals(rhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+
 }
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
+TRY((((*this).check_types_for_compat(expression_type,subject_type_id,((((*this).generic_inferences))),((case_).marker_span)))));
+if ((!(((((pattern).defaults())).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("Expression patterns cannot have default bindings"sv),((case_).marker_span)))));
+}
+types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),TRY((__jakt_format(Jakt::DeprecatedString("catch-expression({})"sv),expr))),true))));
+JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
+types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
+JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
+
+(final_result_type = result_type);
+types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::Expression((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),checked_expression,checked_body,((case_).marker_span)) } ;
+TRY((((checked_cases).push(checked_match_case))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
+default: {
 {
-if ((!(((lhs_type_id).equals(rhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-}
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 10: {
-{
-if ((!(((lhs_type_id).equals(rhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+}/*switch end*/
+}()
+));
 }
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 18: {
-{
-if ((!(((lhs_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
-TRY((((*this).error(Jakt::DeprecatedString("left side of logical binary operation is not a boolean"sv),lhs_span))));
 }
-if ((!(((rhs_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
-TRY((((*this).error(Jakt::DeprecatedString("right side of logical binary operation is not a boolean"sv),rhs_span))));
+
+((current_case_index++));
+}
+
+}
+}
+
+if ((is_value_match && (!(seen_catch_all)))){
+TRY((((*this).error(Jakt::DeprecatedString("match expression is not exhaustive, a value match must contain an irrefutable 'else' pattern"sv),span))));
 }
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
+}/*switch end*/
+}()
+));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Match>(checked_expr,checked_cases,span,final_result_type.value_or_lazy_evaluated([&] { return types::void_type_id(); }),true))));
+}
+}
+
+ErrorOr<void> typechecker::Typechecker::map_generic_arguments(types::TypeId const type_id,JaktInternal::DynamicArray<types::TypeId> const args) {
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = *((*this).get_type(type_id));
+switch(__jakt_match_variant.index()) {
 case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
 {
-if ((!(((lhs_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
-TRY((((*this).error(Jakt::DeprecatedString("left side of logical binary operation is not a boolean"sv),lhs_span))));
-}
-if ((!(((rhs_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
-TRY((((*this).error(Jakt::DeprecatedString("right side of logical binary operation is not a boolean"sv),rhs_span))));
+types::CheckedStruct const struct_ = ((*this).get_struct(id));
+TRY((((((*this).generic_inferences)).set_all(((struct_).generic_parameters),args))));
 }
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+{
+types::CheckedEnum const enum_ = ((*this).get_enum(id));
+TRY((((((*this).generic_inferences)).set_all(((enum_).generic_parameters),args))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
 {
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
-return (lhs_type_id);
-}
-if (((checked_rhs)->index() == 25 /* OptionalNone */)){
-utility::Span const span = ((checked_rhs)->get<types::CheckedExpression::OptionalNone>()).span;
-types::TypeId const type_id = ((checked_rhs)->get<types::CheckedExpression::OptionalNone>()).type_id;
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if (((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))))))){
-return (lhs_type_id);
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait(id));
+TRY((((((*this).generic_inferences)).set_all(((trait_)->generic_parameters),args))));
 }
-else if ((!(((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))))))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot assign None to a non-optional type"sv),span))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Cannot assign None to a non-optional type"sv),span))));
+return {};
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_throw(NonnullRefPtr<typename parser::ParsedExpression> const expr,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+{
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+types::TypeId const error_type_id = TRY((((*this).find_type_in_prelude(Jakt::DeprecatedString("Error"sv)))));
+if ((!(((((checked_expr)->type())).equals(error_type_id))))){
+TRY((((*this).error(Jakt::DeprecatedString("throw expression does not produce an error"sv),((expr)->span())))));
 }
-NonnullRefPtr<typename types::Type> const lhs_type = TRY((((*this).unwrap_type_from_optional_if_needed(((*this).get_type(lhs_type_id))))));
-if (((lhs_type)->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((lhs_type)->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((lhs_type)->get<types::Type::GenericInstance>()).args;
-if (((((((((*this).program))->get_struct(id))).name) == Jakt::DeprecatedString("WeakPtr"sv)) && (!(((lhs_type_id).equals(rhs_type_id)))))){
-JaktInternal::Optional<types::TypeId> const unified_type = TRY((((*this).unify(((args)[static_cast<i64>(0LL)]),lhs_span,((checked_rhs)->type()),rhs_span))));
-if (((unified_type).has_value())){
-return ((unified_type.value()));
-}
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
+if ((!(((scope)->can_throw)))){
+TRY((((*this).error(Jakt::DeprecatedString("Throw statement needs to be in a try statement or a function marked as throws"sv),((expr)->span())))));
 }
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Throw>(checked_expr,span))));
 }
-types::TypeId const effective_lhs_type_id = TRY((((*this).find_or_add_type_id(lhs_type))));
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,effective_lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-return (((result).value_or(lhs_type_id)));
+
+ErrorOr<void> typechecker::Typechecker::fill_trait_requirements(JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> const names,JaktInternal::DynamicArray<types::TraitId>& trait_requirements,JaktInternal::DynamicArray<types::TypeId>& trait_implementations,types::ScopeId const scope_id) {
+{
+TRY((((((trait_requirements))).ensure_capacity(((names).size())))));
+{
+JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((names).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 27: {
+parser::ParsedNameWithGenericParameters name = (_magic_value.value());
 {
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
+JaktInternal::Optional<types::TypeId> type_id = TRY((((*this).find_type_in_scope(scope_id,((name).name)))));
+if (((type_id).has_value())){
+if (((((*this).get_type((type_id.value()))))->index() == 26 /* Trait */)){
+types::TraitId const trait_id = ((((*this).get_type((type_id.value()))))->get<types::Type::Trait>()).value;
+if ((!(((((name).generic_parameters)).is_empty())))){
+JaktInternal::DynamicArray<types::TypeId> generic_arguments = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((name).generic_parameters)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+NonnullRefPtr<typename parser::ParsedType> argument = (_magic_value.value());
+{
+TRY((((generic_arguments).push(TRY((((*this).typecheck_typename(argument,scope_id,JaktInternal::OptionalNone()))))))));
 }
+
 }
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+
+NonnullRefPtr<typename types::Type> const final_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericTraitInstance>(trait_id,generic_arguments)));
+(type_id = TRY((((*this).find_or_add_type_id(final_type)))));
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+TRY((((((trait_implementations))).push((type_id.value())))));
+TRY((((((trait_requirements))).push(trait_id))));
 }
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Requirement ‘{}’ is not a trait"sv),((name).name)))),((name).name_span)))));
+continue;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 28: {
-{
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
+
 }
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Couldn't find trait ‘{}’"sv),((name).name)))),((name).name_span)))));
+continue;
 }
+
 }
+
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+
 }
+return {};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 29: {
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_dictionary(JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const values,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
 {
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
-}
+if (((*this).dump_try_hints)){
+TRY((((*this).dump_try_hint(span))));
 }
+types::StructId const dictionary_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
+JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> checked_kv_pairs = (TRY((DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
+types::TypeId key_type_id = types::unknown_type_id();
+JaktInternal::Optional<utility::Span> key_type_span = JaktInternal::OptionalNone();
+types::TypeId value_type_id = types::unknown_type_id();
+JaktInternal::Optional<utility::Span> value_type_span = JaktInternal::OptionalNone();
+JaktInternal::Optional<types::TypeId> key_hint = JaktInternal::OptionalNone();
+JaktInternal::Optional<types::TypeId> value_hint = JaktInternal::OptionalNone();
+JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const type_hint_ids = TRY((((*this).get_type_ids_from_type_hint_if_struct_ids_match(type_hint,dictionary_struct_id))));
+if (((type_hint_ids).has_value())){
+(key_hint = (((type_hint_ids.value()))[static_cast<i64>(0LL)]));
+(value_hint = (((type_hint_ids.value()))[static_cast<i64>(1LL)]));
 }
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((values).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>> key__value__ = (_magic_value.value());
+{
+JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>> const jakt__key__value__ = key__value__;
+NonnullRefPtr<typename parser::ParsedExpression> const key = ((jakt__key__value__).template get<0>());
+NonnullRefPtr<typename parser::ParsedExpression> const value = ((jakt__key__value__).template get<1>());
+
+NonnullRefPtr<typename types::CheckedExpression> const checked_key = TRY((((*this).typecheck_expression(key,scope_id,safety_mode,key_hint))));
+types::TypeId const current_key_type_id = ((checked_key)->type());
+NonnullRefPtr<typename types::CheckedExpression> const checked_value = TRY((((*this).typecheck_expression(value,scope_id,safety_mode,value_hint))));
+types::TypeId const current_value_type_id = ((checked_value)->type());
+types::TypeId const VOID_TYPE_ID = types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } );
+if ((((key_type_id).equals(types::unknown_type_id())) && ((value_type_id).equals(types::unknown_type_id())))){
+if (((current_key_type_id).equals(VOID_TYPE_ID))){
+TRY((((*this).error(Jakt::DeprecatedString("Can't create a dictionary with keys of type void"sv),((key)->span())))));
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+if (((current_value_type_id).equals(VOID_TYPE_ID))){
+TRY((((*this).error(Jakt::DeprecatedString("Can't create a dictionary with values of type void"sv),((value)->span())))));
 }
+(key_type_id = current_key_type_id);
+(key_type_span = static_cast<JaktInternal::Optional<utility::Span>>(((key)->span())));
+(value_type_id = current_value_type_id);
+(value_type_span = static_cast<JaktInternal::Optional<utility::Span>>(((value)->span())));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 31: {
-{
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
+else {
+if ((!(((key_type_id).equals(current_key_type_id))))){
+DeprecatedString const key_type_name = TRY((((*this).type_name(key_type_id,false))));
+DeprecatedString const current_key_type_name = TRY((((*this).type_name(current_key_type_id,false))));
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' does not match type '{}' of previous keys in dictionary"sv),current_key_type_name,key_type_name))),((key)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Dictionary was inferred to store keys of type '{}' here"sv),key_type_name))),(key_type_span.value())))));
 }
+if ((!(((value_type_id).equals(current_value_type_id))))){
+DeprecatedString const value_type_name = TRY((((*this).type_name(value_type_id,false))));
+DeprecatedString const current_value_type_name = TRY((((*this).type_name(current_value_type_id,false))));
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' does not match type '{}' of previous values in dictionary"sv),current_value_type_name,value_type_name))),((value)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Dictionary was inferred to store values of type '{}' here"sv),value_type_name))),(value_type_span.value())))));
 }
 }
+
+TRY((((checked_kv_pairs).push((Tuple{checked_key, checked_value})))));
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
+
+if (((key_type_id).equals(types::unknown_type_id()))){
+if (((key_hint).has_value())){
+(key_type_id = (key_hint.value()));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 30: {
-{
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Cannot infer key type for Dictionary<K, V>"sv),span))));
 }
+
 }
+if (((value_type_id).equals(types::unknown_type_id()))){
+if (((value_hint).has_value())){
+(value_type_id = (value_hint.value()));
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Cannot infer value type for Dictionary"sv),span))));
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(dictionary_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({key_type_id, value_type_id})))))))))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::JaktDictionary>(checked_kv_pairs,span,type_id,key_type_id,value_type_id))));
 }
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 22: {
+
+ErrorOr<types::CheckedBlock> typechecker::Typechecker::typecheck_block(parser::ParsedBlock const parsed_block,types::ScopeId const parent_scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const yield_type_hint) {
 {
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
-}
-}
+bool const parent_throws = ((TRY((((*this).get_scope(parent_scope_id)))))->can_throw);
+types::ScopeId const block_scope_id = TRY((((*this).create_scope(parent_scope_id,parent_throws,Jakt::DeprecatedString("block"sv),true))));
+types::CheckedBlock checked_block = types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false);
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((parsed_block).stmts)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+NonnullRefPtr<typename parser::ParsedStatement> parsed_statement = (_magic_value.value());
+{
+if ((!(((((checked_block).control_flow)).is_reachable())))){
+TRY((((*this).error(Jakt::DeprecatedString("Unreachable code"sv),((parsed_statement)->span())))));
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+NonnullRefPtr<typename types::CheckedStatement> const checked_statement = TRY((((*this).typecheck_statement(parsed_statement,block_scope_id,safety_mode,yield_type_hint))));
+(((checked_block).control_flow) = ((((checked_block).control_flow)).updated(((*this).statement_control_flow(checked_statement)))));
+JaktInternal::Optional<utility::Span> const yield_span = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<utility::Span>, ErrorOr<types::CheckedBlock>>{
+auto&& __jakt_match_variant = *parsed_statement;
+switch(__jakt_match_variant.index()) {
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<utility::Span>>(((expr)->span())));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<utility::Span>>(((expr)->span())));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+}/*switch end*/
+}()
+));
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const checked_yield_expression = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>, ErrorOr<types::CheckedBlock>>{
+auto&& __jakt_match_variant = *checked_statement;
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>(expr));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+}/*switch end*/
+}()
+));
+if ((((yield_span).has_value()) && ((checked_yield_expression).has_value()))){
+types::TypeId const type_var_type_id = (((checked_yield_expression.value()))->type());
+types::TypeId const type_ = TRY((((*this).resolve_type_var(type_var_type_id,block_scope_id))));
+if ((((checked_yield_expression.value()))->index() == 25 /* OptionalNone */)){
+(((checked_block).yielded_none) = true);
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+if (((((checked_block).yielded_type)).has_value())){
+TRY((((*this).check_types_for_compat(((((checked_block).yielded_type)).value()),type_,((((*this).generic_inferences))),((yield_span).value())))));
 }
+else {
+(((checked_block).yielded_type) = static_cast<JaktInternal::Optional<types::TypeId>>(type_));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-{
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
+
 }
+TRY((((((checked_block).statements)).push(checked_statement))));
 }
+
 }
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+
+if (((((checked_block).yielded_type)).has_value())){
+(((checked_block).yielded_type) = static_cast<JaktInternal::Optional<types::TypeId>>(TRY((((*this).substitute_typevars_in_type(((((checked_block).yielded_type)).value()),((*this).generic_inferences)))))));
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+return (checked_block);
 }
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
+
+ErrorOr<void> typechecker::Typechecker::typecheck_namespace_default_fields(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
 {
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
-}
-}
+JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+size_t i = (_magic_value.value());
+{
+parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
+types::ScopeId const child_namespace_scope_id = ((children)[i]);
+TRY((((*this).typecheck_namespace_default_fields(child_namespace,child_namespace_scope_id))));
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
+
+{
+JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 25: {
+parser::ParsedRecord record = (_magic_value.value());
 {
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
+if ((((((record).record_type)).index() == 0 /* Struct */) || ((((record).record_type)).index() == 1 /* Class */))){
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
+if ((!(((struct_id).has_value())))){
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find previously added struct"sv)))));
 }
+TRY((((*this).typecheck_struct_default_fields(record,(struct_id.value()),scope_id))));
 }
 }
+
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+
 }
+return {};
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 26: {
+
+ErrorOr<void> typechecker::Typechecker::typecheck_jakt_main(parser::ParsedFunction const parsed_function,types::ScopeId const parent_scope_id) {
 {
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
-if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
-types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
-if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
-types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-return (lhs_type_id);
+DeprecatedString const param_type_error = Jakt::DeprecatedString("Main function  must take a single array of strings as its parameter"sv);
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const func_ids = TRY((((*this).find_functions_with_name_in_scope(parent_scope_id,Jakt::DeprecatedString("main"sv)))));
+if (((((func_ids.value())).size()) > static_cast<size_t>(1ULL))){
+TRY((((*this).error(Jakt::DeprecatedString("Function 'main' declared multiple times."sv),((parsed_function).name_span)))));
 }
+if ((((((parsed_function).params)).size()) > static_cast<size_t>(1ULL))){
+TRY((((*this).error(param_type_error,((parsed_function).name_span)))));
 }
+if ((!(((((parsed_function).params)).is_empty())))){
+if (((((((((((parsed_function).params))[static_cast<i64>(0LL)])).variable)).parsed_type))->index() == 3 /* JaktArray */)){
+NonnullRefPtr<typename parser::ParsedType> const inner = ((((((((((parsed_function).params))[static_cast<i64>(0LL)])).variable)).parsed_type))->get<parser::ParsedType::JaktArray>()).inner;
+utility::Span const span = ((((((((((parsed_function).params))[static_cast<i64>(0LL)])).variable)).parsed_type))->get<parser::ParsedType::JaktArray>()).span;
+if (((inner)->index() == 0 /* Name */)){
+DeprecatedString const name = ((inner)->get<parser::ParsedType::Name>()).name;
+utility::Span const span = ((inner)->get<parser::ParsedType::Name>()).span;
+if ((name != Jakt::DeprecatedString("String"sv))){
+TRY((((*this).error(param_type_error,span))));
 }
 }
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+else {
+TRY((((*this).error(param_type_error,span))));
 }
-if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+
+}
+else {
+TRY((((*this).error(param_type_error,((parsed_function).name_span)))));
+}
+
 }
+DeprecatedString const return_type_error = Jakt::DeprecatedString("Main function  must return c_int"sv);
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = *((parsed_function).return_type);
+switch(__jakt_match_variant.index()) {
+case 13: {
+{
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
 {
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-}
-(type_id = lhs_type_id);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-{
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-}
-(type_id = lhs_type_id);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-{
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-}
-(type_id = lhs_type_id);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-{
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-}
-(type_id = lhs_type_id);
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 4: {
-{
-JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
-if ((!(((result).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+if ((name != Jakt::DeprecatedString("c_int"sv))){
+TRY((((*this).error(return_type_error,span))));
 }
-(type_id = lhs_type_id);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
+TRY((((*this).error(return_type_error,((parsed_function).return_type_span)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-return (type_id);
 }
+return {};
 }
 
-ErrorOr<JaktInternal::Optional<types::StructId>> typechecker::Typechecker::find_struct_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
+ErrorOr<types::TypeId> typechecker::Typechecker::typecheck_binary_operation(NonnullRefPtr<typename types::CheckedExpression> const checked_lhs,parser::BinaryOperator const op,NonnullRefPtr<typename types::CheckedExpression> const checked_rhs,types::ScopeId const scope_id,utility::Span const span) {
 {
-return (TRY((((((*this).program))->find_struct_in_scope(scope_id,name)))));
+types::TypeId const lhs_type_id = ((checked_lhs)->type());
+types::TypeId const rhs_type_id = ((checked_rhs)->type());
+utility::Span const lhs_span = ((checked_lhs)->span());
+utility::Span const rhs_span = ((checked_rhs)->span());
+types::TypeId type_id = ((checked_lhs)->type());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<types::TypeId>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 20: {
+{
+if (((op).index() == 32 /* NoneCoalescingAssign */)){
+if (((checked_lhs)->index() == 24 /* Var */)){
+NonnullRefPtr<types::CheckedVariable> const var = ((checked_lhs)->get<types::CheckedExpression::Var>()).var;
+utility::Span const span = ((checked_lhs)->get<types::CheckedExpression::Var>()).span;
+if ((!(((var)->is_mutable)))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("left-hand side of ??= must be a mutable variable"sv),span,Jakt::DeprecatedString("This variable isn't marked as mutable"sv),((var)->definition_span)))));
+return (types::unknown_type_id());
+}
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("left-hand side of ??= must be a mutable variable"sv),span))));
+return (types::unknown_type_id());
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_function(parser::ParsedFunction const parsed_function,types::ScopeId const parent_scope_id) {
-{
-bool const in_comptime_function_call = ((*this).in_comptime_function_call);
-ScopeGuard __jakt_var_441([&] {
-(((*this).in_comptime_function_call) = in_comptime_function_call);
-});
-(((*this).in_comptime_function_call) = ((parsed_function).is_comptime));
-if (((!(((((parsed_function).generic_parameters)).is_empty()))) && (!(((parsed_function).must_instantiate))))){
-return {};
 }
-JaktInternal::Optional<types::FunctionId> const function_id = TRY((((*this).find_function_matching_signature_in_scope(parent_scope_id,parsed_function))));
-if (((function_id).has_value())){
-(((*this).current_function_id) = (function_id.value()));
-if ((((parsed_function).name) == Jakt::DeprecatedString("main"sv))){
-TRY((((*this).typecheck_jakt_main(parsed_function,parent_scope_id))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if (((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))))))){
+if (((lhs_type_id).equals(rhs_type_id))){
+return (lhs_type_id);
 }
-NonnullRefPtr<types::CheckedFunction> checked_function = ((*this).get_function((function_id.value())));
-types::ScopeId const function_scope_id = ((checked_function)->function_scope_id);
-parser::FunctionLinkage const function_linkage = ((checked_function)->linkage);
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((checked_function)->params)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+types::TypeId const inner_type_id = ((args)[static_cast<i64>(0LL)]);
+if (((inner_type_id).equals(rhs_type_id))){
+return (inner_type_id);
 }
-types::CheckedParameter param = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const variable = ((param).variable);
-types::VarId const var_id = TRY((((module)->add_variable(variable))));
-TRY((((*this).add_var_to_scope(function_scope_id,((variable)->name),var_id,((variable)->definition_span)))));
+}
+else {
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,Jakt::DeprecatedString("Left side of ?? must be an Optional but isn't"sv),lhs_span))));
 }
 
 }
+else {
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,Jakt::DeprecatedString("Left side of ?? must be an Optional but isn't"sv),lhs_span))));
 }
 
-types::TypeId function_return_type_id = TRY((((*this).typecheck_typename(((parsed_function).return_type),function_scope_id,JaktInternal::OptionalNone()))));
-if (((!(((parsed_function).is_fat_arrow))) && (((((parsed_function).return_type))->index() == 13 /* Empty */) && (((parsed_function).name) != Jakt::DeprecatedString("main"sv))))){
-(function_return_type_id = types::void_type_id());
-}
-if (((function_return_type_id).equals(types::never_type_id()))){
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(function_scope_id))));
-(((scope)->can_throw) = true);
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (lhs_type_id);
 }
-types::CheckedBlock const block = TRY((((*this).typecheck_block(((parsed_function).block),function_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
-if (((((block).yielded_type)).has_value())){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Functions are not allowed to yield values"sv),(((((parsed_function).block)).find_yield_span()).value()),Jakt::DeprecatedString("You might want to return instead"sv),(((((parsed_function).block)).find_yield_keyword_span()).value())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 32: {
+{
+if (((op).index() == 32 /* NoneCoalescingAssign */)){
+if (((checked_lhs)->index() == 24 /* Var */)){
+NonnullRefPtr<types::CheckedVariable> const var = ((checked_lhs)->get<types::CheckedExpression::Var>()).var;
+utility::Span const span = ((checked_lhs)->get<types::CheckedExpression::Var>()).span;
+if ((!(((var)->is_mutable)))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("left-hand side of ??= must be a mutable variable"sv),span,Jakt::DeprecatedString("This variable isn't marked as mutable"sv),((var)->definition_span)))));
+return (types::unknown_type_id());
 }
-types::TypeId const return_type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId,ErrorOr<void>>{
-auto __jakt_enum_value = (((function_return_type_id).equals(types::unknown_type_id())));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((*this).infer_function_return_type(block)));
 }
 else {
-return JaktInternal::ExplicitValue(TRY((((*this).resolve_type_var(function_return_type_id,function_scope_id)))));
+TRY((((*this).error(Jakt::DeprecatedString("left-hand side of ??= must be a mutable variable"sv),span))));
+return (types::unknown_type_id());
 }
-}()))
-;
-if (((!(((function_linkage).index() == 1 /* External */))) && ((!(((return_type_id).equals(types::void_type_id())))) && (!(((((block).control_flow)).always_transfers_control())))))){
-if ((((return_type_id).equals(types::never_type_id())) && (!(((((block).control_flow)).never_returns()))))){
-TRY((((*this).error(Jakt::DeprecatedString("Control reaches end of never-returning function"sv),((parsed_function).name_span)))));
+
 }
-else if ((!(((((block).control_flow)).never_returns())))){
-TRY((((*this).error(Jakt::DeprecatedString("Control reaches end of non-void function"sv),((parsed_function).name_span)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if (((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))))))){
+if (((lhs_type_id).equals(rhs_type_id))){
+return (lhs_type_id);
 }
+types::TypeId const inner_type_id = ((args)[static_cast<i64>(0LL)]);
+if (((inner_type_id).equals(rhs_type_id))){
+return (inner_type_id);
 }
-(((checked_function)->block) = block);
-(((checked_function)->return_type_id) = return_type_id);
-(((*this).current_function_id) = JaktInternal::OptionalNone());
 }
 else {
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("Previously defined function {} not found in scope {}"sv),((parsed_function).name),parent_scope_id)))))));
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,Jakt::DeprecatedString("Left side of ?? must be an Optional but isn't"sv),lhs_span))));
 }
 
 }
-return {};
+else {
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,Jakt::DeprecatedString("Left side of ?? must be an Optional but isn't"sv),lhs_span))));
 }
 
-ErrorOr<void> typechecker::Typechecker::check_type_argument_requirements(types::TypeId const generic_argument,JaktInternal::DynamicArray<types::TraitId> const constraints,utility::Span const arg_span) {
-{
-if ((!(((constraints).is_empty())))){
-JaktInternal::Tuple<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>,utility::Span> const implemented_traits_decl_span_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>,utility::Span>, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((*this).get_type(generic_argument));
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue((Tuple{((((*this).get_enum(id))).trait_implementations), ((((*this).get_enum(id))).name_span)}));
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((Tuple{((((*this).get_enum(id))).trait_implementations), ((((*this).get_enum(id))).name_span)}));
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue((Tuple{((((*this).get_struct(id))).trait_implementations), ((((*this).get_struct(id))).name_span)}));
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((Tuple{((((*this).get_struct(id))).trait_implementations), ((((*this).get_struct(id))).name_span)}));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("None coalescing (??) with incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (lhs_type_id);
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
-{
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot use ‘{}’ here as only enums, structs and classes can implement the required traits"sv),TRY((((*this).type_name(generic_argument,false))))))),arg_span))));
+case 5: {
 {
-return ErrorOr<void>{};
+if ((!(((lhs_type_id).equals(rhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
-abort();
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const implemented_traits = ((implemented_traits_decl_span_).template get<0>());
-utility::Span const decl_span = ((implemented_traits_decl_span_).template get<1>());
-
+case 6: {
 {
-JaktInternal::ArrayIterator<types::TraitId> _magic = ((constraints).iterator());
-for (;;){
-JaktInternal::Optional<types::TraitId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if ((!(((lhs_type_id).equals(rhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-types::TraitId constraint = (_magic_value.value());
-{
-DeprecatedString const trait_name = ((((((*this).program))->get_trait(constraint)))->name);
-JaktInternal::Optional<JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const implemented_trait = ((implemented_traits).get(trait_name));
-if (((!(((implemented_trait).has_value()))) || (!((((((implemented_trait.value())).template get<0>())).equals(constraint)))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Cannot use ‘{}’ here as it doesn't implement the trait ‘{}’"sv),TRY((((*this).type_name(generic_argument,false)))),trait_name))),arg_span,Jakt::DeprecatedString("Consider implementing the required trait for this type"sv),decl_span))));
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 7: {
+{
+if ((!(((lhs_type_id).equals(rhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 8: {
+{
+if ((!(((lhs_type_id).equals(rhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
-else {
-return {};
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 9: {
+{
+if ((!(((lhs_type_id).equals(rhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
-return {};
-}
-
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_inline_cpp(parser::ParsedBlock const block,utility::Span const span,types::SafetyMode const safety_mode) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 10: {
 {
-if (((safety_mode).index() == 0 /* Safe */)){
-TRY((((*this).error(Jakt::DeprecatedString("Use of inline cpp block outside of unsafe block"sv),span))));
+if ((!(((lhs_type_id).equals(rhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary comparison between incompatible types ({} vs {})"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-JaktInternal::DynamicArray<DeprecatedString> strings = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((block).stmts)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
-NonnullRefPtr<typename parser::ParsedStatement> statement = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 18: {
 {
-if (((statement)->index() == 0 /* Expression */)){
-NonnullRefPtr<typename parser::ParsedExpression> const expr = ((statement)->get<parser::ParsedStatement::Expression>()).expr;
-if (((expr)->index() == 2 /* QuotedString */)){
-DeprecatedString const val = ((expr)->get<parser::ParsedExpression::QuotedString>()).val;
-utility::Span const span = ((expr)->get<parser::ParsedExpression::QuotedString>()).span;
-TRY((((strings).push(val))));
+if ((!(((lhs_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
+TRY((((*this).error(Jakt::DeprecatedString("left side of logical binary operation is not a boolean"sv),lhs_span))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected block of strings"sv),span))));
+if ((!(((rhs_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
+TRY((((*this).error(Jakt::DeprecatedString("right side of logical binary operation is not a boolean"sv),rhs_span))));
 }
-
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Expected block of strings"sv),span))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 19: {
+{
+if ((!(((lhs_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
+TRY((((*this).error(Jakt::DeprecatedString("left side of logical binary operation is not a boolean"sv),lhs_span))));
 }
-
+if ((!(((rhs_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
+TRY((((*this).error(Jakt::DeprecatedString("right side of logical binary operation is not a boolean"sv),rhs_span))));
 }
-
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 21: {
+{
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+return (lhs_type_id);
 }
-
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::InlineCpp>(strings,span))));
+if (((checked_rhs)->index() == 25 /* OptionalNone */)){
+utility::Span const span = ((checked_rhs)->get<types::CheckedExpression::OptionalNone>()).span;
+types::TypeId const type_id = ((checked_rhs)->get<types::CheckedExpression::OptionalNone>()).type_id;
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if (((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))))))){
+return (lhs_type_id);
 }
+else if ((!(((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))))))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot assign None to a non-optional type"sv),span))));
 }
-
-bool typechecker::Typechecker::is_class(types::TypeId const type_id) const {
-{
-if (((((*this).get_type(type_id)))->index() == 23 /* Struct */)){
-types::StructId const struct_id = ((((*this).get_type(type_id)))->get<types::Type::Struct>()).value;
-return (((((((*this).get_struct(struct_id))).record_type)).index() == 1 /* Class */));
 }
 else {
-return (false);
+TRY((((*this).error(Jakt::DeprecatedString("Cannot assign None to a non-optional type"sv),span))));
 }
 
+}
+NonnullRefPtr<typename types::Type> const lhs_type = TRY((((*this).unwrap_type_from_optional_if_needed(((*this).get_type(lhs_type_id))))));
+if (((lhs_type)->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((lhs_type)->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((lhs_type)->get<types::Type::GenericInstance>()).args;
+if (((((((((*this).program))->get_struct(id))).name) == Jakt::DeprecatedString("WeakPtr"sv)) && (!(((lhs_type_id).equals(rhs_type_id)))))){
+JaktInternal::Optional<types::TypeId> const unified_type = TRY((((*this).unify(((args)[static_cast<i64>(0LL)]),lhs_span,((checked_rhs)->type()),rhs_span))));
+if (((unified_type).has_value())){
+return ((unified_type.value()));
 }
 }
-
-ErrorOr<void> typechecker::Typechecker::typecheck_struct_fields(parser::ParsedRecord const record,types::StructId const struct_id) {
-{
-types::CheckedStruct structure = ((*this).get_struct(struct_id));
-types::ScopeId const checked_struct_scope_id = ((((*this).get_struct(struct_id))).scope_id);
-types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
-(((*this).current_struct_type_id) = struct_type_id);
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = struct_type_id);
-ScopeGuard __jakt_var_442([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
-JaktInternal::DynamicArray<parser::ParsedField> const parsed_fields = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<parser::ParsedField>, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((record).record_type);
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Struct>();JaktInternal::DynamicArray<parser::ParsedField> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(fields);
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Class>();JaktInternal::DynamicArray<parser::ParsedField> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(fields);
-};/*case end*/
-default: {
-{
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_struct_fields cannot handle non-structs"sv)))));
 }
+types::TypeId const effective_lhs_type_id = TRY((((*this).find_or_add_type_id(lhs_type))));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,effective_lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+}
+return (((result).value_or(lhs_type_id)));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
+case 27: {
 {
-JaktInternal::ArrayIterator<parser::ParsedField> _magic = ((parsed_fields).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
-parser::ParsedField unchecked_member = (_magic_value.value());
-{
-parser::ParsedVarDecl const parsed_var_decl = ((unchecked_member).var_decl);
-types::TypeId const checked_member_type = TRY((((*this).typecheck_typename(((parsed_var_decl).parsed_type),checked_struct_scope_id,((parsed_var_decl).name)))));
-TRY((((*this).check_that_type_doesnt_contain_reference(checked_member_type,((((parsed_var_decl).parsed_type))->span())))));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::VarId const variable_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(((parsed_var_decl).name),checked_member_type,((parsed_var_decl).is_mutable),((parsed_var_decl).span),JaktInternal::OptionalNone(),TRY((((*this).typecheck_visibility(((unchecked_member).visibility),checked_struct_scope_id)))),JaktInternal::OptionalNone())))))));
-TRY((((((structure).fields)).push(types::CheckedField(variable_id,JaktInternal::OptionalNone(),((unchecked_member).default_value))))));
 }
-
 }
 }
-
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-return {};
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
-
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_block_statement(parser::ParsedBlock const parsed_block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
-{
-types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(parsed_block,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-if (((((checked_block).yielded_type)).has_value())){
-TRY((((*this).error(Jakt::DeprecatedString("A block used as a statement cannot yield values, as the value cannot be observed in any way"sv),(((parsed_block).find_yield_span()).value())))));
 }
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Block>(checked_block,span))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 28: {
+{
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
 }
-
-typechecker::Typechecker::Typechecker(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, types::ModuleId a_current_module_id, JaktInternal::Optional<types::TypeId> a_current_struct_type_id, JaktInternal::Optional<types::FunctionId> a_current_function_id, bool a_inside_defer, size_t a_checkidx, bool a_ignore_errors, bool a_dump_type_hints, bool a_dump_try_hints, u64 a_lambda_count, types::GenericInferences a_generic_inferences, JaktInternal::Optional<types::TypeId> a_self_type_id, DeprecatedString a_root_module_name, bool a_in_comptime_function_call, bool a_had_an_error) :compiler(move(a_compiler)), program(move(a_program)), current_module_id(move(a_current_module_id)), current_struct_type_id(move(a_current_struct_type_id)), current_function_id(move(a_current_function_id)), inside_defer(move(a_inside_defer)), checkidx(move(a_checkidx)), ignore_errors(move(a_ignore_errors)), dump_type_hints(move(a_dump_type_hints)), dump_try_hints(move(a_dump_try_hints)), lambda_count(move(a_lambda_count)), generic_inferences(move(a_generic_inferences)), self_type_id(move(a_self_type_id)), root_module_name(move(a_root_module_name)), in_comptime_function_call(move(a_in_comptime_function_call)), had_an_error(move(a_had_an_error)){}
-
-bool typechecker::Typechecker::is_subclass_of(types::TypeId const ancestor_type_id,types::TypeId const child_type_id) const {
-{
-NonnullRefPtr<typename types::Type> const ancestor_type = ((*this).get_type(ancestor_type_id));
-NonnullRefPtr<typename types::Type> const child_type = ((*this).get_type(child_type_id));
-if (((ancestor_type)->index() == 23 /* Struct */)){
-types::StructId const ancestor_struct_id = ((ancestor_type)->get<types::Type::Struct>()).value;
-if (((child_type)->index() == 23 /* Struct */)){
-types::StructId const child_struct_id = ((child_type)->get<types::Type::Struct>()).value;
-types::CheckedStruct ancestor_struct = ((*this).get_struct(ancestor_struct_id));
-types::StructId current_struct_id = child_struct_id;
-for (;;){
-types::CheckedStruct const current_struct = ((*this).get_struct(current_struct_id));
-if (((((current_struct).super_struct_id)).has_value())){
-if (((ancestor_struct_id).equals((((current_struct).super_struct_id).value())))){
-return (true);
 }
-(current_struct_id = (((current_struct).super_struct_id).value()));
 }
-else {
-return (false);
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
-return (false);
 }
-else {
-return (false);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 29: {
+{
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
-
 }
-else {
-return (false);
 }
-
 }
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
-ErrorOr<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>>> typechecker::Typechecker::expand_context_for_bindings(NonnullRefPtr<typename parser::ParsedExpression> const condition,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const acc,JaktInternal::Optional<parser::ParsedBlock> const then_block,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const else_statement,utility::Span const span) {
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>>>>{
-auto&& __jakt_match_variant = *condition;
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs = __jakt_match_value.lhs;
-parser::BinaryOperator const& op = __jakt_match_value.op;
-NonnullRefPtr<typename parser::ParsedExpression> const& rhs = __jakt_match_value.rhs;
-{
-if (((op).index() == 18 /* LogicalAnd */)){
-JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const rhs_condition_rhs_then_block_rhs_else_statement_ = TRY((((*this).expand_context_for_bindings(rhs,acc,then_block,else_statement,span))));
-NonnullRefPtr<typename parser::ParsedExpression> const rhs_condition = ((rhs_condition_rhs_then_block_rhs_else_statement_).template get<0>());
-JaktInternal::Optional<parser::ParsedBlock> const rhs_then_block = ((rhs_condition_rhs_then_block_rhs_else_statement_).template get<1>());
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const rhs_else_statement = ((rhs_condition_rhs_then_block_rhs_else_statement_).template get<2>());
-
-NonnullRefPtr<typename parser::ParsedExpression> accumulated_condition = rhs_condition;
-return (TRY((((*this).expand_context_for_bindings(lhs,accumulated_condition,rhs_then_block,rhs_else_statement,span)))));
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-parser::UnaryOperator const& op = __jakt_match_value.op;
+case 31: {
 {
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>>>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::UnaryOperator::IsEnumVariant>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& bindings = __jakt_match_value.bindings;
-{
-NonnullRefPtr<typename parser::ParsedExpression> const unary_op_single_condition = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::Is(inner) } ,span)));
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> outer_if_stmts = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({}))));
-{
-JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = ((bindings).iterator());
-for (;;){
-JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::EnumVariantPatternArgument binding = (_magic_value.value());
-{
-parser::ParsedVarDecl const var = parser::ParsedVarDecl(((binding).binding),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),false,JaktInternal::OptionalNone(),((binding).span));
-NonnullRefPtr<typename parser::ParsedExpression> const enum_variant_arg = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::EnumVariantArg>(expr,binding,inner,span)));
-TRY((((outer_if_stmts).push(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(var,enum_variant_arg,span)))))));
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
-
 }
 }
-
-NonnullRefPtr<typename parser::ParsedExpression> inner_condition = condition;
-if (((then_block).has_value())){
-if (((acc).has_value())){
-(inner_condition = (acc.value()));
-TRY((((outer_if_stmts).push(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::If>(inner_condition,(then_block.value()),else_statement,span)))))));
 }
-else {
-TRY((((outer_if_stmts).push_values((((((then_block.value())).stmts)))))));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
-parser::ParsedBlock const new_then_block = parser::ParsedBlock(outer_if_stmts);
-return (TRY((((*this).expand_context_for_bindings(unary_op_single_condition,JaktInternal::OptionalNone(),new_then_block,else_statement,span)))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 30: {
 {
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-NonnullRefPtr<typename parser::ParsedExpression> base_condition = condition;
-if (((acc).has_value())){
-(base_condition = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::BinaryOp>(condition, parser::BinaryOperator { typename parser::BinaryOperator::LogicalAnd() } ,(acc.value()),span))));
 }
-return ((Tuple{base_condition, then_block, else_statement}));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
-
-ErrorOr<JaktInternal::Optional<types::CheckedEnumVariant>> typechecker::Typechecker::get_enum_variant(types::CheckedEnum const enum_,DeprecatedString const variant_name) {
-{
-{
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 22: {
 {
-if ((((variant).name()) == variant_name)){
-return (variant);
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
 }
-
 }
 }
-
-return (JaktInternal::OptionalNone());
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
-
-ErrorOr<void> typechecker::Typechecker::check_implicit_constructor_argument_access(types::ScopeId const caller_scope_id,parser::ParsedCall const call,types::CheckedStruct const struct_) {
-{
-if ((!(TRY((((*this).scope_can_access(caller_scope_id,((struct_).scope_id)))))))){
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
-{
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 23: {
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
-types::CheckedField field = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const variable = ((*this).get_variable(((field).variable_id)));
-DeprecatedString const name = ((*this).get_argument_name(arg));
-if (((((variable)->name) == name) && ((((variable)->visibility)).index() == 1 /* Private */))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't access field '{}' when calling implicit constructor of '{}' because it is marked private"sv),((variable)->name),((struct_).name)))),((arg).template get<1>())))));
-return {};
 }
 }
-
 }
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+}
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
-
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 24: {
+{
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
 }
-
 }
 }
-return {};
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_array(types::ScopeId const scope_id,JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const values,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const fill_size,utility::Span const span,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 25: {
 {
-if (((*this).dump_try_hints)){
-TRY((((*this).dump_try_hint(span))));
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
-if ((!(((TRY((((*this).get_scope(scope_id)))))->can_throw)))){
-DeprecatedString const message = Jakt::DeprecatedString("Array initialization inside non-throwing scope"sv);
-if (((((*this).current_function_id)).has_value())){
-NonnullRefPtr<types::CheckedFunction> const current_function = ((*this).get_function((((*this).current_function_id).value())));
-TRY((((*this).error_with_hint(message,span,TRY((__jakt_format(Jakt::DeprecatedString("Add `throws` keyword to function {}"sv),((current_function)->name)))),((current_function)->name_span)))));
 }
-else {
-TRY((((*this).error(message,span))));
 }
-
 }
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> repeat = JaktInternal::OptionalNone();
-if (((fill_size).has_value())){
-NonnullRefPtr<typename parser::ParsedExpression> const fill_size_value = ((fill_size).value());
-NonnullRefPtr<typename types::CheckedExpression> const fill_size_checked = TRY((((*this).typecheck_expression_and_dereference_if_needed(fill_size_value,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-types::TypeId const fill_size_type = ((fill_size_checked)->type());
-if ((!(((*this).is_integer(fill_size_type))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' is not convertible to an integer. Only integer values can be array fill size expressions."sv),TRY((((*this).type_name(fill_size_type,false))))))),((fill_size_value)->span())))));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-(repeat = fill_size_checked);
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
-types::StructId const array_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-types::TypeId inner_type_id = types::unknown_type_id();
-JaktInternal::Optional<utility::Span> inferred_type_span = JaktInternal::OptionalNone();
-JaktInternal::Optional<types::TypeId> inner_hint = JaktInternal::OptionalNone();
-JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const type_hint_ids = TRY((((*this).get_type_ids_from_type_hint_if_struct_ids_match(type_hint,array_struct_id))));
-if (((type_hint_ids).has_value())){
-(inner_hint = (((type_hint_ids.value()))[static_cast<i64>(0LL)]));
 }
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> vals = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedExpression>>::create_with({}))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 26: {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedExpression>> _magic = ((values).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((((*this).get_type(lhs_type_id)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type(lhs_type_id)))->get<types::Type::GenericInstance>()).args;
+if ((((id).equals(weak_ptr_struct_id)) && ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->index() == 23 /* Struct */))){
+types::StructId const lhs_struct_id = ((((*this).get_type(((args)[static_cast<i64>(0LL)]))))->get<types::Type::Struct>()).value;
+if (((((*this).get_type(rhs_type_id)))->index() == 23 /* Struct */)){
+types::StructId const rhs_struct_id = ((((*this).get_type(rhs_type_id)))->get<types::Type::Struct>()).value;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+return (lhs_type_id);
 }
-NonnullRefPtr<typename parser::ParsedExpression> value = (_magic_value.value());
-{
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression(value,scope_id,safety_mode,inner_hint))));
-types::TypeId const current_value_type_id = ((checked_expr)->type());
-if (((current_value_type_id).equals(types::void_type_id()))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot create an array with values of type void\n"sv),span))));
 }
-if (((inner_type_id).equals(types::unknown_type_id()))){
-(inner_type_id = current_value_type_id);
-(inferred_type_span = ((value)->span()));
 }
-else if ((!(((inner_type_id).equals(current_value_type_id))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' does not match type '{}' of previous values in array"sv),TRY((((*this).type_name(current_value_type_id,false)))),TRY((((*this).type_name(inner_type_id,false))))))),((value)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Array was inferred to store type '{}' here"sv),TRY((((*this).type_name(inner_type_id,false))))))),(inferred_type_span.value())))));
 }
-TRY((((vals).push(checked_expr))));
-}
-
-}
-}
-
-if (((inner_type_id).equals(types::unknown_type_id()))){
-if (((inner_hint).has_value())){
-(inner_type_id = (inner_hint.value()));
-}
-else if ((((type_hint).has_value()) && (((type_hint.value())).equals(types::unknown_type_id())))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot infer generic type for Array<T>"sv),span))));
-}
-}
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id})))))))))));
-if (((type_hint).has_value())){
-TRY((((*this).check_types_for_compat((type_hint.value()),type_id,((((*this).generic_inferences))),span))));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Assignment between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::JaktArray>(vals,repeat,span,type_id,inner_type_id))));
+if ((!(((checked_lhs)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Assignment to immutable variable"sv),((checked_lhs)->span())))));
 }
 }
-
-ErrorOr<NonnullRefPtr<types::Scope>> typechecker::Typechecker::get_scope(types::ScopeId const id) const {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 0: {
 {
-return (TRY((((((*this).program))->get_scope(id)))));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
+(type_id = lhs_type_id);
 }
-
-ErrorOr<bool> typechecker::Typechecker::check_types_for_compat(types::TypeId const lhs_type_id,types::TypeId const rhs_type_id,types::GenericInferences& generic_inferences,utility::Span const span) {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
 {
-if (((((lhs_type_id).equals(rhs_type_id)) || ((lhs_type_id).equals(types::unknown_type_id()))) || ((rhs_type_id).equals(types::unknown_type_id())))){
-return (true);
-}
-NonnullRefPtr<typename types::Type> const lhs_type = ((*this).get_type(lhs_type_id));
-NonnullRefPtr<typename types::Type> const rhs_type = ((*this).get_type(rhs_type_id));
-if (((lhs_type)->index() == 30 /* Self */)){
-if ((!(((((*this).self_type_id)).has_value())))){
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of the 'Self' type"sv),span))));
-}
-else {
-return (TRY((((*this).check_types_for_compat((((*this).self_type_id).value()),rhs_type_id,generic_inferences,span)))));
-}
-
-}
-if (((rhs_type)->index() == 30 /* Self */)){
-if ((!(((((*this).self_type_id)).has_value())))){
-TRY((((*this).error(Jakt::DeprecatedString("Invalid use of the 'Self' type"sv),span))));
-}
-else {
-return (TRY((((*this).check_types_for_compat(lhs_type_id,(((*this).self_type_id).value()),generic_inferences,span)))));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
+(type_id = lhs_type_id);
 }
-DeprecatedString const lhs_type_id_string = TRY((((lhs_type_id).to_string())));
-DeprecatedString const rhs_type_id_string = TRY((((rhs_type_id).to_string())));
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-types::StructId const weakptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-types::StructId const array_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<bool>>{
-auto&& __jakt_match_variant = *lhs_type;
-switch(__jakt_match_variant.index()) {
-case 18: {
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
 {
-JaktInternal::Optional<DeprecatedString> seen_type_id_string = ((((generic_inferences))).get(lhs_type_id_string));
-if (((seen_type_id_string).has_value())){
-types::TypeId const seen_type_id = TRY((types::TypeId::from_string((seen_type_id_string.value()))));
-if (((((*this).get_type(seen_type_id)))->index() == 18 /* TypeVariable */)){
-return (TRY((((*this).check_types_for_compat(seen_type_id,lhs_type_id,generic_inferences,span)))));
-}
-if ((((seen_type_id_string).value()) != rhs_type_id_string)){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(seen_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
-}
-}
-else {
-TRY((((((generic_inferences))).set(lhs_type_id_string,rhs_type_id_string))));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
+(type_id = lhs_type_id);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& lhs_enum_id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& lhs_args = __jakt_match_value.args;
+case 3: {
 {
-if (((rhs_type)->index() == 20 /* GenericEnumInstance */)){
-types::EnumId const rhs_enum_id = ((rhs_type)->get<types::Type::GenericEnumInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const rhs_args = ((rhs_type)->get<types::Type::GenericEnumInstance>()).args;
-if (((lhs_enum_id).equals(rhs_enum_id))){
-types::CheckedEnum const lhs_enum = ((*this).get_enum(lhs_enum_id));
-if ((((lhs_args).size()) == ((rhs_args).size()))){
-size_t idx = static_cast<size_t>(0ULL);
-while ((idx < ((lhs_args).size()))){
-if ((!(TRY((((*this).check_types_for_compat(((lhs_args)[idx]),((rhs_args)[idx]),generic_inferences,span))))))){
-return (false);
-}
-(++(idx));
-}
-}
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("mismatched number of generic parameters for {}"sv),((lhs_enum).name)))),span))));
-return (false);
-}
-
-}
-}
-else {
-if ((!(((rhs_type_id).equals(lhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
-}
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-
+(type_id = lhs_type_id);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& lhs_params = __jakt_match_value.params;
-bool const& lhs_can_throw = __jakt_match_value.can_throw;
-types::TypeId const& lhs_return_type_id = __jakt_match_value.return_type_id;
+case 4: {
 {
-if (((rhs_type)->index() == 29 /* Function */)){
-JaktInternal::DynamicArray<types::TypeId> const rhs_params = ((rhs_type)->get<types::Type::Function>()).params;
-bool const rhs_can_throw = ((rhs_type)->get<types::Type::Function>()).can_throw;
-types::TypeId const rhs_return_type_id = ((rhs_type)->get<types::Type::Function>()).return_type_id;
-if ((!((lhs_can_throw == rhs_can_throw)))){
-DeprecatedString const lhs_throw = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<bool>>{
-auto __jakt_enum_value = (lhs_can_throw);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Yes"sv));
-}
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("No"sv));
-}
-}()))
-;
-DeprecatedString const rhs_throw = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<bool>>{
-auto __jakt_enum_value = (rhs_can_throw);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Yes"sv));
-}
-else {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("No"sv));
+JaktInternal::Optional<types::TypeId> const result = TRY((((*this).unify(rhs_type_id,rhs_span,lhs_type_id,lhs_span))));
+if ((!(((result).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Binary arithmetic operation between incompatible types (‘{}’ and ‘{}’)"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
 }
-}()))
-;
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Function can throw mismatch: expected ‘{}’, but got ‘{}’"sv),lhs_throw,rhs_throw))),span))));
+(type_id = lhs_type_id);
 }
-if ((!((((lhs_params).size()) == ((rhs_params).size()))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Function parameter count mismatch: expected ‘{}’, but got ‘{}’"sv),((lhs_params).size()),((rhs_params).size())))),span))));
-return (false);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
 }
-if ((!(TRY((((*this).check_types_for_compat(lhs_return_type_id,rhs_return_type_id,generic_inferences,span))))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Function type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("The return types differ: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_return_type_id,false)))),TRY((((*this).type_name(rhs_return_type_id,false))))))),span))));
-return (false);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+return (type_id);
 }
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_params).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-size_t i = (_magic_value.value());
+
+ErrorOr<void> typechecker::Typechecker::typecheck_enum_predecl_initial(parser::ParsedRecord const parsed_record,size_t const enum_index,size_t const module_enum_len,types::ScopeId const scope_id) {
 {
-if ((!(TRY((((*this).check_types_for_compat(((lhs_params)[i]),((rhs_params)[i]),generic_inferences,span))))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Function type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("The parameter types differ at argument {}: expected ‘{}’, but got ‘{}’"sv),(JaktInternal::checked_add<size_t>(i,static_cast<size_t>(1ULL))),TRY((((*this).type_name(((lhs_params)[i]),false)))),TRY((((*this).type_name(((rhs_params)[i]),false))))))),span))));
-return (false);
+types::ModuleId const module_id = ((*this).current_module_id);
+types::EnumId const enum_id = types::EnumId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(enum_index,module_enum_len)));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id)))))));
+types::TypeId const enum_type_id = types::TypeId(module_id,(JaktInternal::checked_sub<size_t>(((((((*this).current_module()))->types)).size()),static_cast<size_t>(1ULL))));
+TRY((((*this).add_type_to_scope(scope_id,((parsed_record).name),enum_type_id,((parsed_record).name_span)))));
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = enum_type_id);
+ScopeGuard __jakt_var_429([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+bool const is_boxed = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((parsed_record).record_type);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::SumEnum>();bool const& is_boxed = __jakt_match_value.is_boxed;
+return JaktInternal::ExplicitValue(is_boxed);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+));
+TRY((((((module)->enums)).push(types::CheckedEnum(((parsed_record).name),((parsed_record).name_span),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),(TRY((DynamicArray<types::CheckedEnumVariant>::create_with({})))),(TRY((DynamicArray<types::CheckedField>::create_with({})))),((*this).prelude_scope_id()),((parsed_record).definition_linkage),(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))),((parsed_record).record_type),enum_type_id,enum_type_id,is_boxed)))));
 }
+return {};
 }
 
+ErrorOr<types::TypeId> typechecker::Typechecker::typecheck_generic_resolved_type(DeprecatedString const name,JaktInternal::DynamicArray<types::TypeId> const checked_inner_types,types::ScopeId const scope_id,utility::Span const span) {
+{
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,name))));
+if (((struct_id).has_value())){
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>((struct_id.value()),checked_inner_types))))))));
 }
+JaktInternal::Optional<types::EnumId> const enum_id = TRY((((((*this).program))->find_enum_in_scope(scope_id,name))));
+if (((enum_id).has_value())){
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericEnumInstance>((enum_id.value()),checked_inner_types))))))));
 }
-
+JaktInternal::Optional<types::TraitId> const trait_id = TRY((((((*this).program))->find_trait_in_scope(scope_id,name))));
+if (((trait_id).has_value())){
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericTraitInstance>((trait_id.value()),checked_inner_types))))))));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("could not find {}"sv),name))),span))));
+return (types::unknown_type_id());
 }
-
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_comptime_index(NonnullRefPtr<typename parser::ParsedExpression> const expr,NonnullRefPtr<typename parser::ParsedExpression> const index,types::ScopeId const scope_id,bool const is_optional,types::SafetyMode const safety_mode,utility::Span const span) {
 {
-types::StructId const lhs_struct_id = id;
-JaktInternal::DynamicArray<types::TypeId> const lhs_args = args;
-if ((((lhs_struct_id).equals(optional_struct_id)) || ((lhs_struct_id).equals(weakptr_struct_id)))){
-if ((((lhs_args).size()) > static_cast<size_t>(0ULL))){
-if (((((lhs_args)[static_cast<i64>(0LL)])).equals(rhs_type_id))){
-return (true);
-}
+NonnullRefPtr<typename types::CheckedExpression> const checked_index = TRY((((*this).typecheck_expression(index,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+NonnullRefPtr<interpreter::Interpreter> interpreter = TRY((((*this).interpreter())));
+NonnullRefPtr<interpreter::InterpreterScope> scope = TRY((interpreter::InterpreterScope::from_runtime_scope(scope_id,((*this).program),JaktInternal::OptionalNone())));
+interpreter::StatementResult const index_result = ({ Optional<interpreter::StatementResult> __jakt_var_430;
+auto __jakt_var_431 = [&]() -> ErrorOr<interpreter::StatementResult> { return TRY((((interpreter)->execute_expression(checked_index,scope)))); }();
+if (__jakt_var_431.is_error()) {auto error = __jakt_var_431.release_error();
+{
+warnln(Jakt::DeprecatedString("Error while evaluating comptime index: {}"sv),error);
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::ComptimeIndex>(TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span)))),checked_index,is_optional,span))));
 }
+} else {__jakt_var_430 = __jakt_var_431.release_value();
 }
-if (((rhs_type)->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((rhs_type)->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((rhs_type)->get<types::Type::GenericInstance>()).args;
-types::StructId const rhs_struct_id = id;
-if (((lhs_struct_id).equals(rhs_struct_id))){
-JaktInternal::DynamicArray<types::TypeId> const rhs_args = args;
-types::CheckedStruct const lhs_struct = ((*this).get_struct(lhs_struct_id));
-if ((((lhs_args).size()) == ((rhs_args).size()))){
-size_t idx = static_cast<size_t>(0ULL);
-while ((idx < ((args).size()))){
-if ((!(TRY((((*this).check_types_for_compat(((lhs_args)[idx]),((rhs_args)[idx]),generic_inferences,span))))))){
-return (false);
+__jakt_var_430.release_value(); });
+typechecker::NumericOrStringValue const index_constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<typechecker::NumericOrStringValue, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = index_result;
+switch(__jakt_match_variant.index()) {
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<typechecker::NumericOrStringValue, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::StringValue(val) } );
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index expression evaluation failed: expected numeric or string type, found {}"sv),((value).impl)))),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
 }
-(++(idx));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index expression evaluation returned an invalid object {}"sv),index_result))),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
 }
+};/*case end*/
+}/*switch end*/
+}()
+));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = index_constant;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename typechecker::NumericOrStringValue::StringValue>();
+DeprecatedString const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_struct(expr,val,scope_id,is_optional,safety_mode,span)))));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename typechecker::NumericOrStringValue::UnsignedNumericValue>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_tuple(expr,(infallible_integer_cast<size_t>((val))),scope_id,is_optional,safety_mode,span)))));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename typechecker::NumericOrStringValue::SignedNumericValue>();
+i64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_tuple(expr,(infallible_integer_cast<size_t>((val))),scope_id,is_optional,safety_mode,span)))));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("mismatched number of generic parameters for {}"sv),((lhs_struct).name)))),span))));
-return (false);
 }
 
+ErrorOr<void> typechecker::Typechecker::typecheck_namespace_fields(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
+{
+JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else if (((lhs_struct_id).equals(array_struct_id))){
-types::TypeId const array_value_type_id = ((args)[static_cast<i64>(0LL)]);
-if (((array_value_type_id).equals(types::unknown_type_id()))){
-return (true);
+size_t i = (_magic_value.value());
+{
+parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
+types::ScopeId const child_namespace_scope_id = ((children)[i]);
+TRY((((*this).typecheck_namespace_fields(child_namespace,child_namespace_scope_id))));
 }
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
+
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
 }
 
+{
+JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-if ((!(((rhs_type_id).equals(lhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
+parser::ParsedRecord record = (_magic_value.value());
+{
+if ((((((record).record_type)).index() == 0 /* Struct */) || ((((record).record_type)).index() == 1 /* Class */))){
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
+if ((!(((struct_id).has_value())))){
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find previously added struct"sv)))));
+}
+TRY((((*this).typecheck_struct_fields(record,(struct_id.value())))));
 }
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-{
-if (((lhs_type_id).equals(rhs_type_id))){
-return (true);
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<bool>>{
-auto&& __jakt_match_variant = *rhs_type;
-switch(__jakt_match_variant.index()) {
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+
+}
+return {};
+}
+
+typechecker::Typechecker::Typechecker(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, types::ModuleId a_current_module_id, JaktInternal::Optional<types::TypeId> a_current_struct_type_id, JaktInternal::Optional<types::FunctionId> a_current_function_id, bool a_inside_defer, size_t a_checkidx, bool a_ignore_errors, bool a_dump_type_hints, bool a_dump_try_hints, u64 a_lambda_count, types::GenericInferences a_generic_inferences, JaktInternal::Optional<types::TypeId> a_self_type_id, DeprecatedString a_root_module_name, bool a_in_comptime_function_call, bool a_had_an_error) :compiler(move(a_compiler)), program(move(a_program)), current_module_id(move(a_current_module_id)), current_struct_type_id(move(a_current_struct_type_id)), current_function_id(move(a_current_function_id)), inside_defer(move(a_inside_defer)), checkidx(move(a_checkidx)), ignore_errors(move(a_ignore_errors)), dump_type_hints(move(a_dump_type_hints)), dump_try_hints(move(a_dump_try_hints)), lambda_count(move(a_lambda_count)), generic_inferences(move(a_generic_inferences)), self_type_id(move(a_self_type_id)), root_module_name(move(a_root_module_name)), in_comptime_function_call(move(a_in_comptime_function_call)), had_an_error(move(a_had_an_error)){}
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::cast_to_underlying(NonnullRefPtr<typename parser::ParsedExpression> const expr,types::ScopeId const scope_id,NonnullRefPtr<typename parser::ParsedType> const parsed_type) {
 {
-if (((enum_id).equals(id))){
-types::CheckedEnum const lhs_enum = ((*this).get_enum(enum_id));
-if ((((args).size()) != ((((lhs_enum).generic_parameters)).size()))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("mismatched number of generic parameters for {}"sv),((lhs_enum).name)))),span))));
-return (false);
+NonnullRefPtr<typename parser::ParsedExpression> const cast_expression = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::TypeCast( parser::TypeCast { typename parser::TypeCast::Infallible(parsed_type) } ) } ,((expr)->span()))));
+return (TRY((((*this).typecheck_expression(cast_expression,scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone())))));
 }
-size_t idx = static_cast<size_t>(0ULL);
-while ((idx < ((args).size()))){
-if ((!(TRY((((*this).check_types_for_compat(((((((lhs_enum).generic_parameters))[idx])).type_id),((args)[idx]),generic_inferences,span))))))){
-return (false);
 }
-(++(idx));
+
+ErrorOr<types::TypeId> typechecker::Typechecker::substitute_typevars_in_type(types::TypeId const type_id,types::GenericInferences const generic_inferences) {
+{
+return (TRY((((((*this).program))->substitute_typevars_in_type(type_id,generic_inferences,((*this).current_module_id))))));
 }
 }
+
+DeprecatedString typechecker::Typechecker::get_argument_name(JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const arg) const {
+{
+if ((!(((((arg).template get<0>())).is_empty())))){
+return (((arg).template get<0>()));
+}
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, DeprecatedString>{
+auto&& __jakt_match_variant = *((arg).template get<2>());
+switch(__jakt_match_variant.index()) {
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();DeprecatedString const& name = __jakt_match_value.name;
+{
+return (name);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 18: {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+parser::UnaryOperator const& op = __jakt_match_value.op;
 {
-JaktInternal::Optional<DeprecatedString> const seen_type_id_string = ((((generic_inferences))).get(rhs_type_id_string));
-if (((seen_type_id_string).has_value())){
-if ((((seen_type_id_string).value()) != lhs_type_id_string)){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(TRY((types::TypeId::from_string(((seen_type_id_string).value())))),false))))))),span))));
-return (false);
-}
+if (((((op).index() == 7 /* Reference */) || ((op).index() == 8 /* MutableReference */)) || ((op).index() == 5 /* Dereference */))){
+if (((expr)->index() == 9 /* Var */)){
+DeprecatedString const name = ((expr)->get<parser::ParsedExpression::Var>()).name;
+return (name);
 }
-else {
-TRY((((((generic_inferences))).set(lhs_type_id_string,rhs_type_id_string))));
 }
-
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-if ((!(((rhs_type_id).equals(lhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
-}
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
+return (Jakt::DeprecatedString(""sv));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& lhs_struct_id = __jakt_match_value.value;
-{
-if (((lhs_type_id).equals(rhs_type_id))){
-return (true);
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<bool>>{
-auto&& __jakt_match_variant = *rhs_type;
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::TypeId,types::ScopeId>>> typechecker::Typechecker::find_type_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
 {
-if ((!(((lhs_struct_id).equals(id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
+return (TRY((((((*this).program))->template for_each_scope_accessible_unqualified_from_scope<JaktInternal::Tuple<types::TypeId,types::ScopeId>>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>>> {
+{
+JaktInternal::Optional<types::TypeId> const maybe_type = ((((TRY((((*this).get_scope(scope_id)))))->types)).get(name));
+if (((maybe_type).has_value())){
+return ( typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>> { typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>>::Break((Tuple{(maybe_type.value()), scope_id})) } );
 }
-types::CheckedStruct const lhs_struct = ((*this).get_struct(lhs_struct_id));
-if ((((args).size()) != ((((lhs_struct).generic_parameters)).size()))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("mismatched number of generic parameters for {}"sv),((lhs_struct).name)))),span))));
-return (false);
+return ( typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>> { typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>>::Continue() } );
 }
-size_t idx = static_cast<size_t>(0ULL);
-while ((idx < ((args).size()))){
-if ((!(TRY((((*this).check_types_for_compat(((((((lhs_struct).generic_parameters))[idx])).type_id),((args)[idx]),generic_inferences,span))))))){
-return (false);
-}
-(++(idx));
-}
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 18: {
-{
-JaktInternal::Optional<DeprecatedString> const seen_type_id_string = ((((generic_inferences))).get(rhs_type_id_string));
-if (((seen_type_id_string).has_value())){
-if ((((seen_type_id_string).value()) != lhs_type_id_string)){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(TRY((types::TypeId::from_string(((seen_type_id_string).value())))),false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
 }
+)))))));
 }
-else {
-TRY((((((generic_inferences))).set(lhs_type_id_string,rhs_type_id_string))));
 }
 
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+ErrorOr<types::FunctionId> typechecker::Typechecker::typecheck_and_specialize_generic_function(types::FunctionId const function_id,JaktInternal::DynamicArray<types::TypeId> const generic_arguments,types::ScopeId const parent_scope_id,JaktInternal::Optional<types::TypeId> const this_type_id,types::GenericInferences const generic_substitutions,JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const type_args,utility::Span const call_span,JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>> const args) {
 {
-NonnullRefPtr<typename types::Type> const rhs_type = ((*this).get_type(rhs_type_id));
-if (((*this).is_subclass_of(lhs_type_id,rhs_type_id))){
-return (true);
-}
-if ((!(((rhs_type_id).equals(lhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
+NonnullRefPtr<types::CheckedFunction> checked_function = ((*this).get_function(function_id));
+if ((!(((((checked_function)->parsed_function)).has_value())))){
+return (function_id);
 }
+size_t const specialization_index = ((((((checked_function)->generics))->specializations)).size());
+TRY((((((((checked_function)->generics))->specializations)).push(generic_arguments))));
+types::ModuleId const old_module_id = ((*this).current_module_id);
+ScopeGuard __jakt_var_432([&] {
+(((*this).current_module_id) = old_module_id);
+});
+(((*this).current_module_id) = ((((checked_function)->function_scope_id)).module_id));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::FunctionId const new_function_id = ((module)->next_function_id());
+parser::ParsedFunction parsed_function = ((checked_function)->to_parsed_function());
+types::ScopeId const scope_id = TRY((((*this).create_scope(((((checked_function)->generics))->base_scope_id),((parsed_function).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("function-specialization({})"sv),((parsed_function).name)))),true))));
+if ((((((parsed_function).generic_parameters)).size()) != ((generic_arguments).size()))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Generic function {} expects {} generic arguments, but {} were given"sv),((parsed_function).name),((((parsed_function).generic_parameters)).size()),((generic_arguments).size())))),((parsed_function).name_span)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+if (((((((parsed_function).generic_parameters)).size()) <= ((generic_arguments).size())) && (((((parsed_function).generic_parameters)).size()) <= ((((((checked_function)->generics))->params)).size())))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_function).generic_parameters)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
-types::TypeId const& lhs_rawptr_type_id = __jakt_match_value.value;
+size_t i = (_magic_value.value());
 {
-if (((lhs_rawptr_type_id).equals(rhs_type_id))){
-return (true);
+utility::Span arg_span = call_span;
+if ((((type_args).size()) > i)){
+(arg_span = ((((type_args)[i]))->span()));
 }
-if (((rhs_type)->index() == 25 /* RawPtr */)){
-types::TypeId const rhs_rawptr_type_id = ((rhs_type)->get<types::Type::RawPtr>()).value;
-if ((!(TRY((((*this).check_types_for_compat(lhs_rawptr_type_id,rhs_rawptr_type_id,generic_inferences,span))))))){
-return (false);
+if ((((generic_arguments).size()) > i)){
+TRY((((*this).check_type_argument_requirements(((generic_arguments)[i]),((((((((((checked_function)->generics))->params))[i])).checked_parameter)).constraints),arg_span))));
 }
 }
-else {
-if ((!(((rhs_type_id).equals(lhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
+
 }
 }
 
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
-types::TypeId const& lhs_inner_type_id = __jakt_match_value.value;
+utility::Span const span = ((parsed_function).name_span);
 {
-if (((rhs_type)->index() == 27 /* Reference */)){
-types::TypeId const rhs_inner_type_id = ((rhs_type)->get<types::Type::Reference>()).value;
-if ((!(TRY((((*this).check_types_for_compat(lhs_inner_type_id,rhs_inner_type_id,generic_inferences,span))))))){
-return (false);
+JaktInternal::DictionaryIterator<DeprecatedString,DeprecatedString> _magic = ((((generic_substitutions).iterator())).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> substitution = (_magic_value.value());
+{
+if (((((*this).get_type(TRY((types::TypeId::from_string(((substitution).template get<0>())))))))->index() == 18 /* TypeVariable */)){
+DeprecatedString const type_name = ((((*this).get_type(TRY((types::TypeId::from_string(((substitution).template get<0>())))))))->get<types::Type::TypeVariable>()).name;
+TRY((((*this).add_type_to_scope(scope_id,type_name,TRY((types::TypeId::from_string(((substitution).template get<1>())))),span))));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
-types::TypeId const& lhs_inner_type_id = __jakt_match_value.value;
-{
-if (((rhs_type)->index() == 28 /* MutableReference */)){
-types::TypeId const rhs_inner_type_id = ((rhs_type)->get<types::Type::MutableReference>()).value;
-if ((!(TRY((((*this).check_types_for_compat(lhs_inner_type_id,rhs_inner_type_id,generic_inferences,span))))))){
-return (false);
 }
+
+(((parsed_function).must_instantiate) = true);
+(((checked_function)->is_instantiated) = true);
+(((*this).current_function_id) = static_cast<JaktInternal::Optional<types::FunctionId>>(new_function_id));
+TRY((((*this).typecheck_function_predecl(parsed_function,scope_id,this_type_id,((checked_function)->generics)))));
+TRY((((*this).typecheck_function(parsed_function,scope_id))));
+(((*this).current_function_id) = JaktInternal::OptionalNone());
+NonnullRefPtr<types::Scope> base_scope = TRY((((*this).get_scope((((TRY((((*this).get_scope(((((checked_function)->generics))->base_scope_id))))))->parent).value())))));
+TRY(((((((((base_scope)->functions)).get(((checked_function)->name))).value())).push(new_function_id))));
+NonnullRefPtr<types::CheckedFunction> function = ((*this).get_function(new_function_id));
+(((function)->specialization_index) = specialization_index);
+return (new_function_id);
 }
 else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
+return (function_id);
 }
 
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-if ((((((generic_inferences))).map_name(rhs_type_id_string)) != ((((generic_inferences))).map_name(lhs_type_id_string)))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
-return (false);
-}
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-return (true);
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_lambda(JaktInternal::DynamicArray<parser::ParsedCapture> const captures,JaktInternal::DynamicArray<parser::ParsedParameter> const params,bool const can_throw,bool const is_fat_arrow,NonnullRefPtr<typename parser::ParsedType> const return_type,parser::ParsedBlock const block,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode) {
-{
-NonnullRefPtr<typename parser::ParsedType> const synthetic_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Function>(params,can_throw,return_type,span)));
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-ScopeGuard __jakt_var_443([&] {
+ErrorOr<JaktInternal::Optional<types::ScopeId>> typechecker::Typechecker::required_scope_id_in_hierarchy_for(NonnullRefPtr<typename types::CheckedExpression> const expr,types::ScopeId const current_scope_id) {
 {
-((((*this).generic_inferences)).restore(old_generic_inferences));
-}
-
-});
-types::TypeId type_id = TRY((((*this).typecheck_typename(synthetic_type,scope_id,JaktInternal::OptionalNone()))));
-JaktInternal::Tuple<types::TypeId,types::FunctionId> return_type_id_pseudo_function_id_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<types::TypeId,types::FunctionId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(type_id));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>, ErrorOr<JaktInternal::Optional<types::ScopeId>>>{
+auto&& __jakt_match_variant = *expr;
 switch(__jakt_match_variant.index()) {
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
-types::FunctionId const& pseudo_function_id = __jakt_match_value.pseudo_function_id;
-return JaktInternal::ExplicitValue((Tuple{return_type_id, pseudo_function_id}));
+case 0: {
+return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+};/*case end*/
+case 33: {
+return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();types::CheckedUnaryOperator const& op = __jakt_match_value.op;
+NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>, ErrorOr<JaktInternal::Optional<types::ScopeId>>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
 };/*case end*/
 default: {
-{
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("Expected the just-checked function to be of a function type"sv)))));
-}
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
 };/*case end*/
 }/*switch end*/
 }()
-));
-types::TypeId return_type_id = ((return_type_id_pseudo_function_id_).template get<0>());
-types::FunctionId pseudo_function_id = ((return_type_id_pseudo_function_id_).template get<1>());
-
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::ScopeId effective_namespace_parent_scope_id = scope_id;
-NonnullRefPtr<types::Scope> effective_namespace_parent_scope = TRY((((*this).get_scope(scope_id))));
-while (((effective_namespace_parent_scope)->is_block_scope)){
-(effective_namespace_parent_scope_id = (((effective_namespace_parent_scope)->parent).value()));
-(effective_namespace_parent_scope = TRY((((*this).get_scope(effective_namespace_parent_scope_id)))));
-}
-types::ScopeId lambda_scope_id = TRY((((*this).create_scope(effective_namespace_parent_scope_id,can_throw,Jakt::DeprecatedString("lambda"sv),true))));
-bool is_capturing_everything = false;
-JaktInternal::DynamicArray<types::CheckedCapture> checked_captures = (TRY((DynamicArray<types::CheckedCapture>::create_with({}))));
-bool has_dependent_capture = false;
+)));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_433; {
+JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
 {
-JaktInternal::ArrayIterator<parser::ParsedCapture> _magic = ((captures).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedCapture> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedCapture capture = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
 {
-if (((capture).index() == 4 /* AllByReference */)){
-TRY((((checked_captures).push( types::CheckedCapture { typename types::CheckedCapture::AllByReference(Jakt::DeprecatedString(""sv),((capture).span())) } ))));
-if ((!(is_capturing_everything))){
-(is_capturing_everything = true);
-(lambda_scope_id = TRY((((*this).create_scope(scope_id,can_throw,Jakt::DeprecatedString("lambda"sv),true)))));
+(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,TRY((((*this).required_scope_id_in_hierarchy_for(val,current_scope_id)))))))));
 }
+
 }
-else if (((TRY((((*this).find_var_in_scope(scope_id,((capture).name())))))).has_value())){
-DeprecatedString const name = ((capture).name());
-utility::Span const span = ((capture).span());
-TRY((((checked_captures).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedCapture, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = capture;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( types::CheckedCapture { typename types::CheckedCapture::ByValue(name,span) } );
+}
+
+__jakt_var_433 = final_scope_id; goto __jakt_label_403;
+
+}
+__jakt_label_403:; __jakt_var_433.release_value(); }));
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( types::CheckedCapture { typename types::CheckedCapture::ByReference(name,span) } );
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( types::CheckedCapture { typename types::CheckedCapture::ByMutableReference(name,span) } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(({ Optional<types::CheckedCapture> __jakt_var_444; {
-(has_dependent_capture = true);
-if ((!(((*this).in_comptime_function_call)))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Comptime dependency capture ‘{}’ is only allowed in comptime function calls"sv),name))),span))));
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_434; {
+JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
+{
+(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,TRY((((*this).required_scope_id_in_hierarchy_for(val,current_scope_id)))))))));
+}
+
 }
-__jakt_var_444 =  types::CheckedCapture { typename types::CheckedCapture::ByComptimeDependency(name,span) } ; goto __jakt_label_413;
+}
+
+__jakt_var_434 = final_scope_id; goto __jakt_label_404;
 
 }
-__jakt_label_413:; __jakt_var_444.release_value(); }));
+__jakt_label_404:; __jakt_var_434.release_value(); }));
 };/*case end*/
-case 4: {
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_435; {
+JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
 {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("AllByReference capture should not be looked up by name"sv)))));
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-))))));
-if ((!(is_capturing_everything))){
-NonnullRefPtr<types::CheckedVariable> const var = (TRY((((*this).find_var_in_scope(scope_id,((capture).name()))))).value());
-bool const is_this = (((var)->name) == Jakt::DeprecatedString("this"sv));
-types::VarId const var_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(name,((var)->type_id),(((var)->is_mutable) && ((is_this || ((capture).index() == 1 /* ByReference */)) || ((capture).index() == 2 /* ByMutableReference */))),((var)->definition_span),((var)->type_span),((var)->visibility),((var)->owner_scope))))))));
-TRY((((*this).add_var_to_scope(lambda_scope_id,name,var_id,span))));
+NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
+{
+(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,TRY((((*this).required_scope_id_in_hierarchy_for(val,current_scope_id)))))))));
 }
+
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Variable '{}' not found"sv),((capture).name())))),span))));
 }
 
-}
+__jakt_var_435 = final_scope_id; goto __jakt_label_405;
 
 }
+__jakt_label_405:; __jakt_var_435.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_436; {
+JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> key__val__ = (_magic_value.value());
+{
+JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> const jakt__key__val__ = key__val__;
+NonnullRefPtr<typename types::CheckedExpression> const key = ((jakt__key__val__).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const val = ((jakt__key__val__).template get<1>());
+
+(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,TRY((((*this).scope_lifetime_union(TRY((((*this).required_scope_id_in_hierarchy_for(key,current_scope_id)))),TRY((((*this).required_scope_id_in_hierarchy_for(val,current_scope_id)))))))))))));
 }
 
-if ((!(is_capturing_everything))){
-types::ScopeId current_scope_id = scope_id;
-NonnullRefPtr<types::Scope> lambda_scope = TRY((((*this).get_scope(lambda_scope_id))));
-while ((!(((current_scope_id).equals(effective_namespace_parent_scope_id))))){
-NonnullRefPtr<types::Scope> const current_scope = TRY((((*this).get_scope(current_scope_id))));
-TRY((((((lambda_scope)->resolution_mixins)).push(current_scope_id))));
-(current_scope_id = (((current_scope)->parent).value()));
 }
 }
-JaktInternal::DynamicArray<types::CheckedParameter> checked_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
-bool first = true;
+
+__jakt_var_436 = final_scope_id; goto __jakt_label_406;
+
+}
+__jakt_label_406:; __jakt_var_436.release_value(); }));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ComptimeIndex>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 19: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 20: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 21: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
+return JaktInternal::ExplicitValue(((var)->owner_scope).value_or_lazy_evaluated([&] { return current_scope_id; }));
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NamespacedVar>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
+return JaktInternal::ExplicitValue(((var)->owner_scope).value_or_lazy_evaluated([&] { return current_scope_id; }));
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 26: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+};/*case end*/
+case 28: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Function>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_437; {
+JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
 {
-JaktInternal::ArrayIterator<parser::ParsedParameter> _magic = ((params).iterator());
+JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedParameter param = (_magic_value.value());
+types::CheckedCapture capture = (_magic_value.value());
 {
-types::CheckedParameter const checked_param = TRY((((*this).typecheck_parameter(param,scope_id,first,JaktInternal::OptionalNone(),JaktInternal::OptionalNone()))));
-TRY((((checked_params).push(checked_param))));
-types::VarId const var_id = TRY((((module)->add_variable(((checked_param).variable)))));
-TRY((((*this).add_var_to_scope(lambda_scope_id,((((checked_param).variable))->name),var_id,((((checked_param).variable))->definition_span)))));
-(first = false);
+JaktInternal::Optional<types::ScopeId> scope_id = JaktInternal::OptionalNone();
+if ((((capture).index() == 2 /* ByMutableReference */) || ((capture).index() == 1 /* ByReference */))){
+JaktInternal::Optional<JaktInternal::Optional<types::ScopeId>> const scope_id = ((TRY((((*this).find_var_in_scope(current_scope_id,((capture).name())))))).map([](auto& _value) { return _value->owner_scope; }));
+}
+(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,scope_id)))));
 }
 
 }
 }
 
-JaktInternal::Optional<types::FunctionId> const previous_function_id = ((*this).current_function_id);
-(((*this).current_function_id) = pseudo_function_id);
-ScopeGuard __jakt_var_445([&] {
+__jakt_var_437 = final_scope_id; goto __jakt_label_407;
+
+}
+__jakt_label_407:; __jakt_var_437.release_value(); }));
+};/*case end*/
+case 30: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::DependentFunction>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_438; {
+JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
 {
-(((*this).current_function_id) = previous_function_id);
+JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-});
-if (has_dependent_capture){
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::DependentFunction>(checked_captures,checked_params,can_throw,return_type_id,block,span,type_id,pseudo_function_id,lambda_scope_id))));
+types::CheckedCapture capture = (_magic_value.value());
+{
+JaktInternal::Optional<types::ScopeId> scope_id = JaktInternal::OptionalNone();
+if ((((capture).index() == 2 /* ByMutableReference */) || ((capture).index() == 1 /* ByReference */))){
+JaktInternal::Optional<JaktInternal::Optional<types::ScopeId>> const scope_id = ((TRY((((*this).find_var_in_scope(current_scope_id,((capture).name())))))).map([](auto& _value) { return _value->owner_scope; }));
 }
-types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(block,lambda_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-if (((return_type_id).equals(types::unknown_type_id()))){
-bool return_type_updated = false;
-if (((!(is_fat_arrow)) && ((return_type)->index() == 13 /* Empty */))){
-(return_type_id = types::void_type_id());
-(return_type_updated = true);
+(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,scope_id)))));
 }
-else if ((is_fat_arrow && ((!(((((checked_block).statements)).is_empty()))) && (((((((checked_block).statements)).last()).value()))->index() == 8 /* Return */)))){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const val = (((((((checked_block).statements)).last()).value()))->get<types::CheckedStatement::Return>()).val;
-if (((val).has_value())){
-(return_type_id = TRY((((*this).resolve_type_var((((val.value()))->type()),lambda_scope_id)))));
-(return_type_updated = true);
+
 }
 }
-if (return_type_updated){
-(type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
-bool const& can_throw = __jakt_match_value.can_throw;
-types::FunctionId const& pseudo_function_id = __jakt_match_value.pseudo_function_id;
-return JaktInternal::ExplicitValue(TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Function>(params,can_throw,return_type_id,pseudo_function_id))))))));
-};/*case end*/
-default: {
-{
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("Expected the just-checked function to be of a function type"sv)))));
+
+__jakt_var_438 = final_scope_id; goto __jakt_label_408;
+
 }
+__jakt_label_408:; __jakt_var_438.release_value(); }));
 };/*case end*/
-}/*switch end*/
+case 31: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 32: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+case 34: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
 }
 }
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Function>(checked_captures,checked_params,can_throw,return_type_id,checked_block,span,type_id,pseudo_function_id,lambda_scope_id))));
-}
-}
 
-types::CheckedStruct typechecker::Typechecker::get_struct(types::StructId const id) const {
+NonnullRefPtr<types::CheckedFunction> typechecker::Typechecker::get_function(types::FunctionId const id) const {
 {
-return (((((*this).program))->get_struct(id)));
+return (((((*this).program))->get_function(id)));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_return(JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const expr,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode) {
+ErrorOr<JaktInternal::Optional<typechecker::TraitImplementationDescriptor>> typechecker::Typechecker::find_any_singular_trait_implementation(types::TypeId const type_id,JaktInternal::DynamicArray<DeprecatedString> const trait_names,types::ScopeId const scope_id,utility::Span const span) {
 {
-if (((*this).inside_defer)){
-TRY((((*this).error(Jakt::DeprecatedString("‘return’ is not allowed inside ‘defer’"sv),span))));
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((trait_names).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-if ((!(((expr).has_value())))){
-if (((((*this).current_function_id)).has_value())){
-NonnullRefPtr<types::CheckedFunction> const current_function = ((*this).get_function((((*this).current_function_id).value())));
-NonnullRefPtr<typename types::Type> const return_type = ((*this).get_type(((current_function)->return_type_id)));
-if (((!(((return_type)->index() == 0 /* Void */))) && (!(((return_type)->index() == 16 /* Unknown */))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("’return’ with no value in function ’{}’ returning ’{}’"sv),((current_function)->name),TRY((((*this).type_name(((current_function)->return_type_id),false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("Add return value of type ’{}’ here"sv),TRY((((*this).type_name(((current_function)->return_type_id),false))))))),span))));
+DeprecatedString trait_name = (_magic_value.value());
+{
+JaktInternal::Optional<typechecker::TraitImplementationDescriptor> const maybe_impl = TRY((((*this).find_singular_trait_implementation(type_id,trait_name,scope_id,span))));
+if (((maybe_impl).has_value())){
+return (maybe_impl);
 }
 }
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Return>(JaktInternal::OptionalNone(),span))));
+
 }
-if (((!((((((*this).current_function_id)).has_value()) && ((((*this).get_function((((*this).current_function_id).value()))))->is_comptime)))) && (((expr.value()))->index() == 25 /* Function */))){
-TRY((((*this).error(Jakt::DeprecatedString("Returning a function is not currently supported"sv),span))));
-}
-JaktInternal::Optional<types::TypeId> type_hint = JaktInternal::OptionalNone();
-if (((((*this).current_function_id)).has_value())){
-(type_hint = static_cast<JaktInternal::Optional<types::TypeId>>(((((*this).get_function((((*this).current_function_id).value()))))->return_type_id)));
 }
-JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const new_condition_new_then_block_new_else_statement_ = TRY((((*this).expand_context_for_bindings((expr.value()),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),span))));
-NonnullRefPtr<typename parser::ParsedExpression> const new_condition = ((new_condition_new_then_block_new_else_statement_).template get<0>());
-JaktInternal::Optional<parser::ParsedBlock> const new_then_block = ((new_condition_new_then_block_new_else_statement_).template get<1>());
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const new_else_statement = ((new_condition_new_then_block_new_else_statement_).template get<2>());
 
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(new_condition,scope_id,safety_mode,type_hint,span))));
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Return>(checked_expr,span))));
+return (JaktInternal::OptionalNone());
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::check_that_type_doesnt_contain_reference(types::TypeId const type_id,utility::Span const span) {
+ErrorOr<void> typechecker::Typechecker::specialize_trait(types::TraitId const trait_id,JaktInternal::DynamicArray<types::TypeId> const generic_parameters) {
 {
-if (TRY((((*this).type_contains_reference(type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Reference type ‘{}’ not usable in this context"sv),TRY((((*this).type_name(type_id,false))))))),span))));
-}
-}
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait(trait_id));
+if (((((trait_)->generic_parameters)).is_empty())){
 return {};
 }
-
-ErrorOr<types::FunctionId> typechecker::Typechecker::typecheck_and_specialize_generic_function(types::FunctionId const function_id,JaktInternal::DynamicArray<types::TypeId> const generic_arguments,types::ScopeId const parent_scope_id,JaktInternal::Optional<types::TypeId> const this_type_id,types::GenericInferences const generic_substitutions,JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const type_args,utility::Span const call_span,JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>> const args) {
-{
-NonnullRefPtr<types::CheckedFunction> checked_function = ((*this).get_function(function_id));
-if ((!(((((checked_function)->parsed_function)).has_value())))){
-return (function_id);
-}
-size_t const specialization_index = ((((((checked_function)->generics))->specializations)).size());
-TRY((((((((checked_function)->generics))->specializations)).push(generic_arguments))));
-types::ModuleId const old_module_id = ((*this).current_module_id);
-ScopeGuard __jakt_var_446([&] {
-(((*this).current_module_id) = old_module_id);
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericTraitInstance>(trait_id,generic_parameters))))))));
+ScopeGuard __jakt_var_439([&] {
+(((*this).self_type_id) = old_self_type_id);
 });
-(((*this).current_module_id) = ((((checked_function)->function_scope_id)).module_id));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::FunctionId const new_function_id = ((module)->next_function_id());
-parser::ParsedFunction parsed_function = ((checked_function)->to_parsed_function());
-types::ScopeId const scope_id = TRY((((*this).create_scope(((((checked_function)->generics))->base_scope_id),((parsed_function).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("function-specialization({})"sv),((parsed_function).name)))),true))));
-if ((((((parsed_function).generic_parameters)).size()) != ((generic_arguments).size()))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Generic function {} expects {} generic arguments, but {} were given"sv),((parsed_function).name),((((parsed_function).generic_parameters)).size()),((generic_arguments).size())))),((parsed_function).name_span)))));
-}
-if (((((((parsed_function).generic_parameters)).size()) <= ((generic_arguments).size())) && (((((parsed_function).generic_parameters)).size()) <= ((((((checked_function)->generics))->params)).size())))){
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_function).generic_parameters)).size()))});
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((trait_)->generic_parameters)).size()))});
 for (;;){
 JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
@@ -4676,306 +4634,239 @@ break;
 }
 size_t i = (_magic_value.value());
 {
-utility::Span arg_span = call_span;
-if ((((type_args).size()) > i)){
-(arg_span = ((((type_args)[i]))->span()));
+types::CheckedGenericParameter const parameter = ((((trait_)->generic_parameters))[i]);
+types::TypeId const type = ((generic_parameters)[i]);
+TRY((((*this).check_types_for_compat(((parameter).type_id),type,((((*this).generic_inferences))),((parameter).span)))));
 }
-if ((((generic_arguments).size()) > i)){
-TRY((((*this).check_type_argument_requirements(((generic_arguments)[i]),((((((((((checked_function)->generics))->params))[i])).checked_parameter)).constraints),arg_span))));
+
 }
 }
 
 }
+return {};
 }
 
-utility::Span const span = ((parsed_function).name_span);
+ErrorOr<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>>> typechecker::Typechecker::typecheck_match_variant(parser::ParsedMatchCase const case_,types::TypeId const subject_type_id,size_t const variant_index,JaktInternal::Optional<types::TypeId> const final_result_type,types::CheckedEnumVariant const variant,JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const variant_arguments,JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const default_bindings,utility::Span const arguments_span,types::ScopeId const scope_id,types::SafetyMode const safety_mode) {
 {
-JaktInternal::DictionaryIterator<DeprecatedString,DeprecatedString> _magic = ((((generic_substitutions).iterator())).iterator());
+JaktInternal::Optional<DeprecatedString> covered_name = JaktInternal::OptionalNone();
+types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),TRY((__jakt_format(Jakt::DeprecatedString("catch-enum-variant({})"sv),((variant).name())))),true))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>>>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
+{
+(covered_name = name);
+if ((!(((variant_arguments).is_empty())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case '{}' cannot have arguments"sv),name))),arguments_span))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
+types::TypeId const& type_id = __jakt_match_value.type_id;
+utility::Span const& span = __jakt_match_value.span;
+{
+(covered_name = name);
+if ((!(((variant_arguments).is_empty())))){
+if ((((variant_arguments).size()) != static_cast<size_t>(1ULL))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case ‘{}’ must have exactly one argument"sv),name))),span))));
+}
+else {
+parser::EnumVariantPatternArgument const variant_argument = ((variant_arguments)[static_cast<i64>(0LL)]);
+types::TypeId const variable_type_id = TRY((((*this).substitute_typevars_in_type(type_id,((*this).generic_inferences)))));
+types::VarId const var_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(((variant_argument).binding),variable_type_id,((variant_argument).is_mutable),span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())))))));
+TRY((((*this).add_var_to_scope(new_scope_id,((variant_argument).binding),var_id,span))));
+}
+
+}
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
+{
+(covered_name = name);
+JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> field_variables = (TRY((DynamicArray<NonnullRefPtr<types::CheckedVariable>>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,DeprecatedString> substitution = (_magic_value.value());
+types::VarId var_id = (_magic_value.value());
 {
-if (((((*this).get_type(TRY((types::TypeId::from_string(((substitution).template get<0>())))))))->index() == 18 /* TypeVariable */)){
-DeprecatedString const type_name = ((((*this).get_type(TRY((types::TypeId::from_string(((substitution).template get<0>())))))))->get<types::Type::TypeVariable>()).name;
-TRY((((*this).add_type_to_scope(scope_id,type_name,TRY((types::TypeId::from_string(((substitution).template get<1>())))),span))));
-}
+TRY((((field_variables).push(((((*this).program))->get_variable(var_id))))));
 }
 
 }
 }
 
-(((parsed_function).must_instantiate) = true);
-(((checked_function)->is_instantiated) = true);
-(((*this).current_function_id) = static_cast<JaktInternal::Optional<types::FunctionId>>(new_function_id));
-TRY((((*this).typecheck_function_predecl(parsed_function,scope_id,this_type_id,((checked_function)->generics)))));
-TRY((((*this).typecheck_function(parsed_function,scope_id))));
-(((*this).current_function_id) = JaktInternal::OptionalNone());
-NonnullRefPtr<types::Scope> base_scope = TRY((((*this).get_scope((((TRY((((*this).get_scope(((((checked_function)->generics))->base_scope_id))))))->parent).value())))));
-TRY(((((((((base_scope)->functions)).get(((checked_function)->name))).value())).push(new_function_id))));
-NonnullRefPtr<types::CheckedFunction> function = ((*this).get_function(new_function_id));
-(((function)->specialization_index) = specialization_index);
-return (new_function_id);
+JaktInternal::Set<DeprecatedString> seen_names = (TRY((Set<DeprecatedString>::create_with_values({}))));
+{
+JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = ((variant_arguments).iterator());
+for (;;){
+JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-return (function_id);
+parser::EnumVariantPatternArgument arg = (_magic_value.value());
+{
+if ((!(((((arg).name)).has_value())))){
+bool found_field_name = false;
+JaktInternal::DynamicArray<DeprecatedString> field_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<types::CheckedVariable>> _magic = ((field_variables).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
+NonnullRefPtr<types::CheckedVariable> var = (_magic_value.value());
+{
+TRY((((field_names).push(((var)->name)))));
+if ((((var)->name) == ((arg).binding))){
+(found_field_name = true);
 }
 }
 
-ErrorOr<types::TypeId> typechecker::Typechecker::strip_optional_from_type(types::TypeId const type_id) {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<types::TypeId>>{
-auto&& __jakt_match_variant = *((*this).get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_447; {
-if (((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))))))){
-return (((args)[static_cast<i64>(0LL)]));
 }
-__jakt_var_447 = type_id; goto __jakt_label_414;
+}
 
+if ((!(found_field_name))){
+JaktInternal::DynamicArray<DeprecatedString> unused_field_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((field_names).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_414:; __jakt_var_447.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(type_id);
-};/*case end*/
-}/*switch end*/
-}()
-)));
+DeprecatedString field_name = (_magic_value.value());
+{
+if (((seen_names).contains(field_name))){
+continue;
 }
+TRY((((unused_field_names).push(field_name))));
 }
 
-ErrorOr<bool> typechecker::Typechecker::is_scope_directly_accessible_from(types::ScopeId const scope_id,types::ScopeId const from_scope_id) const {
-{
-return (TRY((((((*this).program))->is_scope_directly_accessible_from(scope_id,from_scope_id)))));
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::specialize_trait(types::TraitId const trait_id,JaktInternal::DynamicArray<types::TypeId> const generic_parameters) {
-{
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait(trait_id));
-if (((((trait_)->generic_parameters)).is_empty())){
-return {};
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Match case argument '{}' for struct-like enum variant '{}' cannot be anon"sv),((arg).binding),name))),((arg).span),TRY((__jakt_format(Jakt::DeprecatedString("Available arguments for '{}' are: {}\n"sv),name,utility::join(unused_field_names,Jakt::DeprecatedString(", "sv))))),((arg).span)))));
+continue;
 }
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericTraitInstance>(trait_id,generic_parameters))))))));
-ScopeGuard __jakt_var_448([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
+}
+DeprecatedString const arg_name = ((arg).name).value_or_lazy_evaluated([&] { return ((arg).binding); });
+if (((seen_names).contains(arg_name))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case argument '{}' is already defined"sv),arg_name))),((arg).span)))));
+continue;
+}
+TRY((((seen_names).add(arg_name))));
+JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> matched_field_variable = JaktInternal::OptionalNone();
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((trait_)->generic_parameters)).size()))});
+JaktInternal::ArrayIterator<NonnullRefPtr<types::CheckedVariable>> _magic = ((field_variables).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+NonnullRefPtr<types::CheckedVariable> var = (_magic_value.value());
 {
-types::CheckedGenericParameter const parameter = ((((trait_)->generic_parameters))[i]);
-types::TypeId const type = ((generic_parameters)[i]);
-TRY((((*this).check_types_for_compat(((parameter).type_id),type,((((*this).generic_inferences))),((parameter).span)))));
+if ((((var)->name) == arg_name)){
+(matched_field_variable = var);
+}
 }
 
 }
 }
 
+if (((matched_field_variable).has_value())){
+types::TypeId const substituted_type_id = TRY((((*this).substitute_typevars_in_type((((matched_field_variable.value()))->type_id),((*this).generic_inferences)))));
+utility::Span const matched_span = (((matched_field_variable.value()))->definition_span);
+if (((*this).dump_type_hints)){
+TRY((((*this).dump_type_hint((((matched_field_variable.value()))->type_id),((arg).span)))));
 }
-return {};
+types::VarId const var_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(((arg).binding),substituted_type_id,((arg).is_mutable),matched_span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())))))));
+TRY((((*this).add_var_to_scope(new_scope_id,((arg).binding),var_id,matched_span))));
 }
-
-NonnullRefPtr<types::CheckedTrait> typechecker::Typechecker::get_trait(types::TraitId const id) const {
-{
-return (((((*this).program))->get_trait(id)));
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case argument '{}' does not exist in struct-like enum variant '{}'"sv),arg_name,name))),((arg).span)))));
 }
+
 }
 
-NonnullRefPtr<types::CheckedFunction> typechecker::Typechecker::get_function(types::FunctionId const id) const {
-{
-return (((((*this).program))->get_function(id)));
 }
 }
 
-ErrorOr<JaktInternal::Optional<types::FunctionId>> typechecker::Typechecker::typecheck_method(parser::ParsedFunction const func,types::StructLikeId const parent_id) {
-{
-JaktInternal::DynamicArray<types::CheckedGenericParameter> parent_generic_parameters = (TRY((DynamicArray<types::CheckedGenericParameter>::create_with({}))));
-types::ScopeId parent_scope_id = ((*this).prelude_scope_id());
-parser::DefinitionLinkage parent_definition_linkage =  parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ;
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<types::FunctionId>>>{
-auto&& __jakt_match_variant = parent_id;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-{
-types::CheckedStruct structure = ((*this).get_struct(struct_id));
-(parent_scope_id = ((structure).scope_id));
-(parent_definition_linkage = ((structure).definition_linkage));
-(parent_generic_parameters = ((structure).generic_parameters));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& name = __jakt_match_value.name;
 {
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-(parent_scope_id = ((enum_).scope_id));
-(parent_definition_linkage = ((enum_).definition_linkage));
-(parent_generic_parameters = ((enum_).generic_parameters));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Trait>();
-types::TraitId const& trait_id = __jakt_match_value.value;
-{
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait(trait_id));
-(parent_scope_id = ((trait_)->scope_id));
-(parent_definition_linkage =  parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } );
-(parent_generic_parameters = ((trait_)->generic_parameters));
+(covered_name = name);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-if ((((!(((((func).generic_parameters)).is_empty()))) || (!(((parent_generic_parameters).is_empty())))) && (!(((func).must_instantiate))))){
-return (JaktInternal::OptionalNone());
-}
-JaktInternal::Optional<types::FunctionId> const method_id = TRY((((*this).find_function_matching_signature_in_scope(parent_scope_id,func))));
-if (((method_id).has_value())){
-TRY((((*this).typecheck_function(func,parent_scope_id))));
-return ((method_id.value()));
-}
-else {
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("Previously defined function {} not found in scope {}"sv),((func).name),parent_scope_id)))))));
-}
-
-}
-}
-
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_var_decl(parser::ParsedVarDecl const var,NonnullRefPtr<typename parser::ParsedExpression> const init,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
 {
-types::TypeId lhs_type_id = TRY((((*this).typecheck_typename(((var).parsed_type),scope_id,((var).name)))));
-NonnullRefPtr<typename types::CheckedExpression> checked_expr = TRY((((*this).typecheck_expression(init,scope_id,safety_mode,lhs_type_id))));
-types::TypeId const rhs_type_id = ((checked_expr)->type());
-if (((rhs_type_id).equals(types::void_type_id()))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot assign `void` to a variable"sv),((checked_expr)->span())))));
-}
-if ((((lhs_type_id).equals(types::unknown_type_id())) && (!(((rhs_type_id).equals(types::unknown_type_id())))))){
-(lhs_type_id = rhs_type_id);
-}
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-if (TRY((((*this).type_contains_reference(lhs_type_id))))){
-JaktInternal::Optional<types::ScopeId> const init_scope_id = TRY((((*this).required_scope_id_in_hierarchy_for(checked_expr,scope_id))));
-if (TRY((((*this).scope_lifetime_subsumes(scope_id,init_scope_id))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot assign a reference to a variable that outlives the reference"sv),((checked_expr)->span())))));
-}
-}
-NonnullRefPtr<typename types::Type> const lhs_type = ((*this).get_type(lhs_type_id));
-if (((checked_expr)->index() == 25 /* OptionalNone */)){
-utility::Span const span = ((checked_expr)->get<types::CheckedExpression::OptionalNone>()).span;
-types::TypeId const type_id = ((checked_expr)->get<types::CheckedExpression::OptionalNone>()).type_id;
-if (((lhs_type)->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((lhs_type)->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((lhs_type)->get<types::Type::GenericInstance>()).args;
-if ((!((((id).equals(optional_struct_id)) || ((id).equals(weak_ptr_struct_id)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot assign None to a non-optional type"sv),span))));
-}
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Cannot assign None to a non-optional type"sv),span))));
+JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((default_bindings).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
+DeprecatedString const _ = ((jakt_____default___).template get<0>());
+parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
 
-}
-if (((lhs_type)->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((lhs_type)->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((lhs_type)->get<types::Type::GenericInstance>()).args;
-if (((id).equals(weak_ptr_struct_id))){
-if ((!(((var).is_mutable)))){
-TRY((((*this).error(Jakt::DeprecatedString("Weak reference must be mutable"sv),((var).span)))));
-}
-if (((!(((lhs_type_id).equals(rhs_type_id)))) && ((!(((((args)[static_cast<i64>(0LL)])).equals(rhs_type_id)))) && (!(((rhs_type_id).equals(types::unknown_type_id()))))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
-}
-}
-else if (((id).equals(optional_struct_id))){
-if (((!(((lhs_type_id).equals(rhs_type_id)))) && ((!(((((args)[static_cast<i64>(0LL)])).equals(rhs_type_id)))) && (!(((rhs_type_id).equals(types::unknown_type_id()))))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
-}
-}
-else {
-if (((!(((lhs_type_id).equals(rhs_type_id)))) && (!(((rhs_type_id).equals(types::unknown_type_id())))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
-}
+NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
+TRY((((defaults).push(checked_var_decl))));
 }
 
-}
-else if (((lhs_type)->is_builtin())){
-JaktInternal::Optional<types::NumberConstant> const number_constant = ((checked_expr)->to_number_constant(((*this).program)));
-bool is_rhs_zero = false;
-if (((number_constant).has_value())){
-(is_rhs_zero = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
-auto&& __jakt_match_variant = (number_constant.value());
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Signed>();
-i64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((value == static_cast<i64>(0LL)));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Unsigned>();
-u64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((value == static_cast<u64>(0ULL)));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Floating>();
-f64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((value == static_cast<f64>(0)));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-if (((!((((*this).is_numeric(lhs_type_id)) && is_rhs_zero))) && (((*this).is_integer(lhs_type_id)) ^ ((*this).is_integer(rhs_type_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Garbage>(span))));
-}
-}
-else {
-if (((!(((lhs_type_id).equals(rhs_type_id)))) && (!(((rhs_type_id).equals(types::unknown_type_id())))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
 }
 }
 
-NonnullRefPtr<types::CheckedVariable> const checked_var = TRY((types::CheckedVariable::__jakt_create(((var).name),lhs_type_id,((var).is_mutable),((var).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
-if ((((*this).dump_type_hints) && ((((var).inlay_span)).has_value()))){
-TRY((((*this).dump_type_hint(lhs_type_id,(((var).inlay_span).value())))));
-}
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::VarId const var_id = TRY((((module)->add_variable(checked_var))));
-TRY((((*this).add_var_to_scope(scope_id,((var).name),var_id,((checked_var)->definition_span)))));
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::VarDecl>(var_id,checked_expr,span))));
+JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
+types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
+JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
+
+types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::EnumVariant(defaults,((variant).name()),variant_arguments,subject_type_id,variant_index,new_scope_id,checked_body,((case_).marker_span)) } ;
+return ((Tuple{covered_name, checked_match_case, result_type}));
 }
 }
 
-ErrorOr<JaktInternal::Optional<parser::ParsedNamespace>> typechecker::Typechecker::lex_and_parse_file_contents(utility::FileId const file_id) {
+ErrorOr<void> typechecker::Typechecker::include_prelude() {
 {
-JaktInternal::Tuple<JaktInternal::Optional<utility::FileId>,JaktInternal::DynamicArray<u8>> const old_file_state = ((((*this).compiler))->current_file_state());
-if ((!(((((*this).compiler))->set_current_file(file_id))))){
-return (JaktInternal::OptionalNone());
+DeprecatedString const module_name = Jakt::DeprecatedString("__prelude__"sv);
+jakt__path::Path const file_name = TRY((jakt__path::Path::from_string(module_name)));
+JaktInternal::DynamicArray<u8> const file_contents = (TRY((DynamicArray<u8>::create_with({static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(79), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(79), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(60), static_cast<u8>(83), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(79), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(60), static_cast<u8>(83), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(68), static_cast<u8>(121), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(107), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(100), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(95), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(111), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(38), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(112), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(97), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(100), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(83), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(97), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(100), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(67), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(80), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(80), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(101), static_cast<u8>(107), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(121), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(111), static_cast<u8>(102), static_cast<u8>(102), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(80), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(95), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(102), static_cast<u8>(56), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(121), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(98), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(98), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(117), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(119), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(121), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(119), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(119), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(119), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(66), static_cast<u8>(117), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(66), static_cast<u8>(117), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(95), static_cast<u8>(106), static_cast<u8>(115), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(66), static_cast<u8>(117), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(80), static_cast<u8>(73), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(87), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(80), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(117), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(40), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(75), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(75), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(111), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(75), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(75), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(65), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(66), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(65), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(66), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(60), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(111), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(60), static_cast<u8>(65), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(60), static_cast<u8>(65), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(85), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(85), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(34), static_cast<u8>(111), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(91), static_cast<u8>(93), static_cast<u8>(34), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(121), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(69), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(95), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(119), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(69), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(34), static_cast<u8>(95), static_cast<u8>(95), static_cast<u8>(106), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(95), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(34), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(95), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(119), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(69), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(111), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(95), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(111), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(95), static_cast<u8>(119), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(117), static_cast<u8>(102), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(119), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(100), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(108), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(95), static_cast<u8>(95), static_cast<u8>(95), static_cast<u8>(106), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(60), static_cast<u8>(85), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(60), static_cast<u8>(85), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(100), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(108), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(100), static_cast<u8>(105), static_cast<u8>(118), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(80), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(80), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(119), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(32), static_cast<u8>(46), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(93), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(38), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(73), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(77), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(70), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(80), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(111), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(66), static_cast<u8>(108), static_cast<u8>(111), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(76), static_cast<u8>(105), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(40), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(108), static_cast<u8>(121), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(40), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(120), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(83), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(77), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(40), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(100), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(66), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(56), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(56), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(74), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(116), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(67), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(73), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(110), static_cast<u8>(107), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(110), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(78), static_cast<u8>(101), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(79), static_cast<u8>(114), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(40), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(80), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(77), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(118), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(100), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(66), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(56), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(56), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(105), static_cast<u8>(56), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(105), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(105), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(105), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(102), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(102), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(74), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(116), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(67), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(73), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(110), static_cast<u8>(107), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(107), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(110), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(78), static_cast<u8>(101), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(79), static_cast<u8>(114), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(40), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(80), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(38), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(77), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(38), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10)}))));
+JaktInternal::Optional<utility::FileId> const old_file_id = ((((*this).compiler))->current_file);
+JaktInternal::DynamicArray<u8> const old_file_contents = ((((*this).compiler))->current_file_contents);
+ScopeGuard __jakt_var_440([&] {
+{
+(((((*this).compiler))->current_file) = old_file_id);
+(((((*this).compiler))->current_file_contents) = old_file_contents);
 }
-ScopeGuard __jakt_var_449([&] {
-((((*this).compiler))->restore_file_state(old_file_state));
+
 });
+utility::FileId const file_id = TRY((((((*this).compiler))->get_file_id_or_register(file_name))));
+(((((*this).compiler))->current_file) = file_id);
+(((((*this).compiler))->current_file_contents) = file_contents);
+types::ModuleId const prelude_module_id = TRY((((*this).create_module(module_name,false,JaktInternal::OptionalNone()))));
+(((*this).current_module_id) = prelude_module_id);
+TRY((((((*this).program))->set_loaded_module(module_name,types::LoadedModule(prelude_module_id,file_id)))));
+types::ScopeId const prelude_scope_id = TRY((((*this).create_scope(JaktInternal::OptionalNone(),false,Jakt::DeprecatedString("prelude"sv),false))));
 JaktInternal::DynamicArray<lexer::Token> const tokens = TRY((lexer::Lexer::lex(((*this).compiler))));
 if (((((*this).compiler))->dump_lexer)){
 {
@@ -4998,539 +4889,605 @@ parser::ParsedNamespace const parsed_namespace = TRY((parser::Parser::parse(((*t
 if (((((*this).compiler))->dump_parser)){
 outln(Jakt::DeprecatedString("{:#}"sv),parsed_namespace);
 }
-return (parsed_namespace);
+((((*this).compiler))->dbg_println(TRY((__jakt_format(Jakt::DeprecatedString("before typechecking parsed prelude, modules ‘{}’"sv),((((*this).program))->modules))))));
+TRY((((*this).typecheck_module(parsed_namespace,prelude_scope_id))));
 }
+return {};
 }
 
-ErrorOr<types::TypeId> typechecker::Typechecker::resolve_type_var(types::TypeId const type_var_type_id,types::ScopeId const scope_id) const {
+ErrorOr<types::ModuleId> typechecker::Typechecker::create_module(DeprecatedString const name,bool const is_root,JaktInternal::Optional<DeprecatedString> const path) {
 {
-types::TypeId current_type_id = type_var_type_id;
-for (;;){
-(current_type_id = TRY((((((*this).generic_inferences)).map(current_type_id)))));
-NonnullRefPtr<typename types::Type> const type_var_type = ((*this).get_type(current_type_id));
-if (((type_var_type)->index() == 18 /* TypeVariable */)){
-DeprecatedString const type_name = ((type_var_type)->get<types::Type::TypeVariable>()).name;
-JaktInternal::Optional<types::TypeId> const maybe_found_type_id = TRY((((*this).find_type_in_scope(scope_id,type_name))));
-if (((maybe_found_type_id).has_value())){
-types::TypeId const found_type_id = ((maybe_found_type_id).value());
-if (((found_type_id).equals(current_type_id))){
-return (current_type_id);
-}
-(current_type_id = found_type_id);
+size_t const new_id = ((((((*this).program))->modules)).size());
+types::ModuleId const module_id = types::ModuleId(new_id);
+NonnullRefPtr<types::Module> const module = TRY((types::Module::__jakt_create(module_id,name,(TRY((DynamicArray<NonnullRefPtr<types::CheckedFunction>>::create_with({})))),(TRY((DynamicArray<types::CheckedStruct>::create_with({})))),(TRY((DynamicArray<types::CheckedEnum>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<types::Scope>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename types::Type>>::create_with({TRY((types::Type::template __jakt_create<typename types::Type::Void>())), TRY((types::Type::template __jakt_create<typename types::Type::Bool>())), TRY((types::Type::template __jakt_create<typename types::Type::U8>())), TRY((types::Type::template __jakt_create<typename types::Type::U16>())), TRY((types::Type::template __jakt_create<typename types::Type::U32>())), TRY((types::Type::template __jakt_create<typename types::Type::U64>())), TRY((types::Type::template __jakt_create<typename types::Type::I8>())), TRY((types::Type::template __jakt_create<typename types::Type::I16>())), TRY((types::Type::template __jakt_create<typename types::Type::I32>())), TRY((types::Type::template __jakt_create<typename types::Type::I64>())), TRY((types::Type::template __jakt_create<typename types::Type::F32>())), TRY((types::Type::template __jakt_create<typename types::Type::F64>())), TRY((types::Type::template __jakt_create<typename types::Type::Usize>())), TRY((types::Type::template __jakt_create<typename types::Type::JaktString>())), TRY((types::Type::template __jakt_create<typename types::Type::CChar>())), TRY((types::Type::template __jakt_create<typename types::Type::CInt>())), TRY((types::Type::template __jakt_create<typename types::Type::Unknown>())), TRY((types::Type::template __jakt_create<typename types::Type::Never>()))})))),(TRY((DynamicArray<NonnullRefPtr<types::CheckedTrait>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<types::CheckedVariable>>::create_with({})))),(TRY((DynamicArray<types::ModuleId>::create_with({})))),path.value_or_lazy_evaluated([&] { return (((((((*this).compiler))->current_file_path()).value())).to_string()); }),is_root)));
+TRY((((((((*this).program))->modules)).push(module))));
+return (module_id);
 }
-else {
-return (current_type_id);
 }
 
+types::ScopeId typechecker::Typechecker::prelude_scope_id() const {
+{
+return (((((*this).program))->prelude_scope_id()));
 }
-else {
-return (current_type_id);
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_namespaced_var_or_simple_enum_constructor_call(DeprecatedString const name,JaktInternal::DynamicArray<DeprecatedString> const namespace_,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint,utility::Span const span) {
+{
+JaktInternal::DynamicArray<types::ScopeId> scopes = (TRY((DynamicArray<types::ScopeId>::create_with({scope_id}))));
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((namespace_).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return (current_type_id);
+DeprecatedString ns = (_magic_value.value());
+{
+types::ScopeId const scope = ((scopes)[(JaktInternal::checked_sub<size_t>(((scopes).size()),static_cast<size_t>(1ULL)))]);
+JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const ns_in_scope = TRY((((*this).find_namespace_in_scope(scope,ns,false))));
+JaktInternal::Optional<types::EnumId> const enum_in_scope = TRY((((((*this).program))->find_enum_in_scope(scope,ns))));
+types::ScopeId next_scope = scope;
+if (((ns_in_scope).has_value())){
+(next_scope = (((ns_in_scope.value())).template get<0>()));
+}
+else if (((enum_in_scope).has_value())){
+(next_scope = ((((*this).get_enum((enum_in_scope.value())))).scope_id));
 }
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Namespace ‘{}’ not found"sv),ns))),span))));
+}
+
+TRY((((scopes).push(next_scope))));
 }
 
-ErrorOr<JaktInternal::Optional<types::TraitId>> typechecker::Typechecker::find_trait_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
-{
-return (TRY((((((*this).program))->find_trait_in_scope(scope_id,name)))));
 }
 }
 
-ErrorOr<bool> typechecker::Typechecker::find_and_import_name_from_scope(DeprecatedString const from_name,utility::Span const from_span,DeprecatedString const to_name,utility::Span const to_span,types::ScopeId const from_scope_id,types::ScopeId const into_scope_id,typechecker::ImportRestrictions const allow) {
-{
-bool found = false;
-if (((allow).functions)){
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_overload_set = TRY((((*this).find_functions_with_name_in_scope(from_scope_id,from_name))));
-if (((maybe_overload_set).has_value())){
-(found = true);
-TRY((((*this).add_function_to_scope(into_scope_id,to_name,(maybe_overload_set.value()),to_span))));
+types::ScopeId const scope = (((scopes).last()).value());
+size_t i = static_cast<size_t>(0ULL);
+size_t const min_length = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = ((((scopes).size()) <= ((namespace_).size())));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((scopes).size()));
 }
+else {
+return JaktInternal::ExplicitValue(((namespace_).size()));
 }
-if (((allow).enums)){
-JaktInternal::Optional<types::EnumId> const maybe_enum_id = TRY((((((*this).program))->find_enum_in_scope(from_scope_id,from_name))));
-if (((maybe_enum_id).has_value())){
-(found = true);
-TRY((((*this).add_enum_to_scope(into_scope_id,to_name,(maybe_enum_id.value()),to_span))));
+}()))
+;
+JaktInternal::DynamicArray<types::CheckedNamespace> checked_namespaces = (TRY((DynamicArray<types::CheckedNamespace>::create_with({}))));
+while ((i < min_length)){
+TRY((((checked_namespaces).push(types::CheckedNamespace(((namespace_)[i]),scope)))));
+((i++));
 }
+JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const var = TRY((((*this).find_var_in_scope(scope,name))));
+if (((var).has_value())){
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NamespacedVar>(checked_namespaces,(var.value()),span))));
 }
-if (((allow).types)){
-JaktInternal::Optional<types::TypeId> const maybe_type_id = TRY((((*this).find_type_in_scope(from_scope_id,from_name))));
-if (((maybe_type_id).has_value())){
-(found = true);
-TRY((((*this).add_type_to_scope(into_scope_id,to_name,(maybe_type_id.value()),to_span))));
-}
+parser::ParsedCall const implicit_constructor_call = parser::ParsedCall(namespace_,name,(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({})))));
+NonnullRefPtr<typename types::CheckedExpression> const call_expression = TRY((((*this).typecheck_call(implicit_constructor_call,scope_id,span,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),safety_mode,type_hint,true))));
+types::TypeId const type_id = ((call_expression)->type());
+types::CheckedCall const call = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedCall, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *call_expression;
+switch(__jakt_match_variant.index()) {
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
+return JaktInternal::ExplicitValue(call);
+};/*case end*/
+default: {
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_call returned something other than a CheckedCall"sv)))));
 }
-if (((allow).structs)){
-JaktInternal::Optional<types::StructId> const maybe_struct_id = TRY((((*this).find_struct_in_scope(from_scope_id,from_name))));
-if (((maybe_struct_id).has_value())){
-(found = true);
-TRY((((*this).add_struct_to_scope(into_scope_id,to_name,(maybe_struct_id.value()),to_span))));
+};/*case end*/
+}/*switch end*/
+}()
+));
+if (((((call).function_id)).has_value())){
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Call>(call,span,type_id))));
 }
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Variable '{}' not found"sv),name))),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NamespacedVar>(checked_namespaces,TRY((types::CheckedVariable::__jakt_create(name,types::unknown_type_id(),false,span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone()))),span))));
 }
-if (((allow).traits)){
-JaktInternal::Optional<types::TraitId> const maybe_trait_id = TRY((((*this).find_trait_in_scope(from_scope_id,from_name))));
-if (((maybe_trait_id).has_value())){
-(found = true);
-TRY((((*this).add_trait_to_scope(into_scope_id,to_name,(maybe_trait_id.value()),to_span))));
 }
+
+ErrorOr<void> typechecker::Typechecker::typecheck_struct_predecl(parser::ParsedRecord const parsed_record,types::StructId const struct_id,types::ScopeId const scope_id) {
+{
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(true))));
+ScopeGuard __jakt_var_441([&] {
+{
+((((*this).generic_inferences)).restore(old_generic_inferences));
 }
-if (((allow).namespaces)){
-JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const maybe_scope_id = TRY((((*this).find_namespace_in_scope(from_scope_id,from_name,false))));
-if (((maybe_scope_id).has_value())){
-(found = true);
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(into_scope_id))));
-TRY((((((scope)->aliases)).set(to_name,(((maybe_scope_id.value())).template get<0>())))));
+
+});
+types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
+(((*this).current_struct_type_id) = struct_type_id);
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = struct_type_id);
+ScopeGuard __jakt_var_442([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+types::ScopeId const struct_scope_id = ((((((((*this).current_module()))->structures))[((struct_id).id)])).scope_id);
+TRY((((*this).add_struct_to_scope(scope_id,((parsed_record).name),struct_id,((parsed_record).name_span)))));
+JaktInternal::Optional<types::StructId> super_struct_id = JaktInternal::OptionalNone();
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((parsed_record).record_type);
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Class>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const& super_parsed_type = __jakt_match_value.super_type;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<void>>{
+auto __jakt_enum_value = (((super_parsed_type).has_value()));
+if (__jakt_enum_value == true) {
+{
+types::TypeId const super_type_id = TRY((((*this).typecheck_typename((super_parsed_type.value()),scope_id,JaktInternal::OptionalNone()))));
+NonnullRefPtr<typename types::Type> const super_type = ((*this).get_type(super_type_id));
+if (((super_type)->index() == 23 /* Struct */)){
+types::StructId const struct_id = ((super_type)->get<types::Type::Struct>()).value;
+(super_struct_id = struct_id);
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Class can only inherit from another class"sv),(((super_parsed_type.value()))->span())))));
 }
-return (found);
+
 }
+return JaktInternal::ExplicitValue<void>();
 }
-
-ErrorOr<void> typechecker::Typechecker::typecheck_extern_import(parser::ParsedExternImport const import_,types::ScopeId const scope_id) {
-{
+else {
 {
-JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((((import_).assigned_namespace)).functions)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedFunction f = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+), JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Struct>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const& super_parsed_type = __jakt_match_value.super_type;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<void>>{
+auto __jakt_enum_value = (((super_parsed_type).has_value()));
+if (__jakt_enum_value == true) {
 {
-if ((!(((((f).linkage)).index() == 1 /* External */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected all functions in an `import extern` to be be external"sv),((f).name_span)))));
+types::TypeId const super_type_id = TRY((((*this).typecheck_typename((super_parsed_type.value()),scope_id,JaktInternal::OptionalNone()))));
+NonnullRefPtr<typename types::Type> const super_type = ((*this).get_type(super_type_id));
+if (((super_type)->index() == 23 /* Struct */)){
+types::StructId const struct_id = ((super_type)->get<types::Type::Struct>()).value;
+(super_struct_id = struct_id);
 }
-if ((((import_).is_c) && (!(((((f).generic_parameters)).is_empty()))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("imported function '{}' is declared to have C linkage, but is generic"sv),((f).name)))),((f).name_span),Jakt::DeprecatedString("this function may not be generic"sv),((f).name_span)))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Struct can only inherit from another struct"sv),(((super_parsed_type.value()))->span())))));
 }
-if ((!(((((((f).block)).stmts)).is_empty())))){
-TRY((((*this).error(Jakt::DeprecatedString("imported extern function is not allowed to have a body"sv),((f).name_span)))));
+
 }
+return JaktInternal::ExplicitValue<void>();
 }
-
+else {
+{
 }
+return JaktInternal::ExplicitValue<void>();
 }
-
+return JaktInternal::ExplicitValue<void>();
+}()))
+), JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((((import_).assigned_namespace)).records)).iterator());
+utility::panic(Jakt::DeprecatedString("Expected Struct or Class in typecheck_struct_predecl"sv));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+(((((module)->structures))[((struct_id).id)]) = types::CheckedStruct(((parsed_record).name),((parsed_record).name_span),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),(TRY((DynamicArray<types::CheckedField>::create_with({})))),struct_scope_id,((parsed_record).definition_linkage),(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))),((parsed_record).record_type),struct_type_id,super_struct_id,((parsed_record).external_name)));
+JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters = ((((((module)->structures))[((struct_id).id)])).generic_parameters);
+TRY((((generic_parameters).ensure_capacity(((((parsed_record).generic_parameters)).size())))));
+{
+JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((parsed_record).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedRecord record = (_magic_value.value());
+parser::ParsedGenericParameter gen_parameter = (_magic_value.value());
 {
-if ((!(((((record).definition_linkage)).index() == 1 /* External */)))){
-TRY((((*this).error(Jakt::DeprecatedString("Expected all records in an `import extern` to be external"sv),((record).name_span)))));
-}
-if ((((import_).is_c) && (!(((((record).generic_parameters)).is_empty()))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("imported {} '{}' is declared to have C linkage, but is generic"sv),((((record).record_type)).record_type_name()),((record).name)))),((record).name_span),TRY((__jakt_format(Jakt::DeprecatedString("this {} may not be generic"sv),((((record).record_type)).record_type_name())))),((record).name_span)))));
-}
-}
-
+types::TypeId const parameter_type_id = types::TypeId(((*this).current_module_id),((((((*this).current_module()))->types)).size()));
+types::CheckedGenericParameter parameter = TRY((types::CheckedGenericParameter::make(parameter_type_id,((gen_parameter).span))));
+JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((gen_parameter).name),trait_implementations)))))));
+if (((((gen_parameter).requires_list)).has_value())){
+TRY((((*this).fill_trait_requirements((((gen_parameter).requires_list).value()),((((parameter).constraints))),((trait_implementations)),scope_id))));
 }
+TRY((((generic_parameters).push(parameter))));
+TRY((((*this).add_type_to_scope(struct_scope_id,((gen_parameter).name),parameter_type_id,((gen_parameter).span)))));
 }
 
 }
-return {};
 }
 
-NonnullRefPtr<types::CheckedVariable> typechecker::Typechecker::get_variable(types::VarId const id) const {
+bool const is_extern = ((((parsed_record).definition_linkage)).index() == 1 /* External */);
 {
-return (((((*this).program))->get_variable(id)));
-}
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((parsed_record).methods)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-ErrorOr<void> typechecker::Typechecker::error(DeprecatedString const message,utility::Span const span) {
+parser::ParsedMethod method = (_magic_value.value());
 {
-if ((!(((*this).ignore_errors)))){
-TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::Message(message,span) } ))));
+types::FunctionId const function_id = TRY((((*this).typecheck_function_predecl(((method).parsed_function),struct_scope_id,struct_type_id,JaktInternal::OptionalNone()))));
+NonnullRefPtr<types::CheckedFunction> checked_function = ((*this).get_function(function_id));
+(((checked_function)->is_override) = ((method).is_override));
+(((checked_function)->is_virtual) = ((method).is_virtual));
+(((checked_function)->visibility) = TRY((((*this).typecheck_visibility(((method).visibility),struct_scope_id)))));
+if ((((checked_function)->is_virtual) && ((checked_function)->is_static()))){
+TRY((((*this).error(Jakt::DeprecatedString("Functions cannot be both virtual and static"sv),((checked_function)->name_span)))));
+}
+if ((((checked_function)->is_override) && ((checked_function)->is_static()))){
+TRY((((*this).error(Jakt::DeprecatedString("Functions cannot be both override and static"sv),((checked_function)->name_span)))));
 }
-else {
-(((*this).had_an_error) = true);
 }
 
 }
-return {};
 }
 
-ErrorOr<JaktInternal::DynamicArray<types::FunctionId>> typechecker::Typechecker::resolve_call(parser::ParsedCall const call,JaktInternal::DynamicArray<types::ResolvedNamespace> namespaces,utility::Span const span,types::ScopeId const scope_id,bool const must_be_enum_constructor) {
+if (((((parsed_record).implements_list)).has_value())){
+TRY((((*this).fill_trait_implementation_list((((parsed_record).implements_list).value()),((((((((module)->structures))[((struct_id).id)])).trait_implementations))),struct_scope_id,JaktInternal::OptionalNone()))));
 {
-types::ScopeId current_scope_id = scope_id;
-JaktInternal::DynamicArray<bool> is_base_ns_alias_or_import = (TRY((DynamicArray<bool>::filled(((namespaces).size()), false))));
+JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = (((((parsed_record).implements_list).value())).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::ParsedNameWithGenericParameters implements_entry = (_magic_value.value());
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).namespace_)).size()))});
+JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((implements_entry).name)))));
+if (((trait_id).has_value())){
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((((((((((*this).program))->modules))[(((((trait_id.value())).module)).id)]))->traits))[(((trait_id.value())).id)]);
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t namespace_index = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
 {
-DeprecatedString const scope_name = ((((call).namespace_))[namespace_index]);
-JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const maybe_ns_scope = TRY((((*this).find_namespace_in_scope(current_scope_id,scope_name,false))));
-if (((maybe_ns_scope).has_value())){
-JaktInternal::Tuple<types::ScopeId,bool> const scope_id_is_import_ = (maybe_ns_scope.value());
-types::ScopeId const scope_id = ((scope_id_is_import_).template get<0>());
-bool const is_import = ((scope_id_is_import_).template get<1>());
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
+DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
+types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
 
-if (is_import){
-(((((namespaces)[namespace_index])).name) = ((((((((*this).program))->modules))[((((scope_id).module_id)).id)]))->name));
-}
-(((((namespaces)[namespace_index])).external_name) = ((TRY((((*this).get_scope(scope_id)))))->external_name));
-(((is_base_ns_alias_or_import)[namespace_index]) = (((TRY((((*this).find_namespace_in_scope(current_scope_id,scope_name,true)))).value())).template get<1>()));
-(current_scope_id = scope_id);
+if (((TRY((((*this).find_functions_with_name_in_scope(struct_scope_id,name))))).has_value())){
 continue;
 }
-JaktInternal::Optional<types::StructId> const maybe_struct_scope = TRY((((*this).find_struct_in_scope(current_scope_id,scope_name))));
-if (((maybe_struct_scope).has_value())){
-types::CheckedStruct const structure = ((*this).get_struct((maybe_struct_scope.value())));
-(((((namespaces)[namespace_index])).external_name) = ((structure).external_name));
-(current_scope_id = ((structure).scope_id));
+NonnullRefPtr<types::CheckedFunction> const function = ((((((((((*this).program))->modules))[((((function_id).module)).id)]))->functions))[((function_id).id)]);
+if (((((((function)->block)).statements)).is_empty())){
 continue;
 }
-JaktInternal::Optional<types::EnumId> const maybe_enum_scope = TRY((((((*this).program))->find_enum_in_scope(current_scope_id,scope_name))));
-if (((maybe_enum_scope).has_value())){
-types::CheckedEnum const enum_ = ((*this).get_enum((maybe_enum_scope.value())));
-(current_scope_id = ((enum_).scope_id));
+TRY((((*this).add_function_to_scope(struct_scope_id,name,(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((implements_entry).name_span)))));
+}
+
+}
+}
+
+}
+else {
 continue;
 }
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Not a namespace, enum, class, or struct: ‘{}’"sv),utility::join(((call).namespace_),Jakt::DeprecatedString("::"sv))))),span))));
+
 }
 
 }
 }
 
-types::ScopeId initial_scope_id = current_scope_id;
-JaktInternal::Optional<types::ScopeId> owning_scope = JaktInternal::OptionalNone();
-ScopeGuard __jakt_var_450([&] {
-{
-JaktInternal::DynamicArray<types::ResolvedNamespace> resolved_namespaces = (MUST((DynamicArray<types::ResolvedNamespace>::create_with({}))));
-{
-i64 ns_index = static_cast<i64>(0LL);
-{
-JaktInternal::ArrayIterator<types::ResolvedNamespace> _magic = ((namespaces).iterator());
-for (;;){
-JaktInternal::Optional<types::ResolvedNamespace> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::ResolvedNamespace ns = (_magic_value.value());
-{
-ScopeGuard __jakt_var_451([&] {
-({auto& _jakt_ref = ns_index;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
-});
-if ((!(((is_base_ns_alias_or_import)[ns_index])))){
-MUST((((resolved_namespaces).push(ns))));
+(((((((module)->structures))[((struct_id).id)])).generic_parameters) = generic_parameters);
+(((*this).current_struct_type_id) = JaktInternal::OptionalNone());
 }
+return {};
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_unary_operation(NonnullRefPtr<typename types::CheckedExpression> const checked_expr,types::CheckedUnaryOperator const checked_op,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode) {
+{
+types::TypeId const expr_type_id = ((checked_expr)->type());
+NonnullRefPtr<typename types::Type> const expr_type = ((*this).get_type(expr_type_id));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = checked_op;
+switch(__jakt_match_variant.index()) {
+case 0: {
+{
+if (((*this).is_integer(expr_type_id))){
+if ((!(((checked_expr)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of immutable variable"sv),span))));
 }
 }
-
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of non-numeric value"sv),span))));
 }
 
-if ((!(((owning_scope).has_value())))){
-JaktInternal::DynamicArray<types::ResolvedNamespace> aliased_namespaces = (MUST((DynamicArray<types::ResolvedNamespace>::create_with({}))));
-for (;;){
-NonnullRefPtr<types::Scope> const scope = MUST((((*this).get_scope(current_scope_id))));
-if (((((scope)->alias_path)).has_value())){
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>((((((scope)->alias_path).value())).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((*this).is_integer(expr_type_id))){
+if ((!(((checked_expr)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of immutable variable"sv),span))));
 }
-size_t i = (_magic_value.value());
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of non-numeric value"sv),span))));
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
 {
-MUST((((aliased_namespaces).push((((((scope)->alias_path).value()))[(JaktInternal::checked_sub<size_t>(i,static_cast<size_t>(1ULL)))])))));
+if (((*this).is_integer(expr_type_id))){
+if ((!(((checked_expr)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of immutable variable"sv),span))));
+}
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of non-numeric value"sv),span))));
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+{
+if (((*this).is_integer(expr_type_id))){
+if ((!(((checked_expr)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of immutable variable"sv),span))));
+}
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of non-numeric value"sv),span))));
 }
 
 }
-else if (((((scope)->namespace_name)).has_value())){
-MUST((((aliased_namespaces).push(types::ResolvedNamespace((((scope)->namespace_name).value()),((scope)->external_name),JaktInternal::OptionalNone())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 9: {
+{
+if ((!(TRY((((*this).check_types_for_compat(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ),((checked_expr)->type()),((((*this).generic_inferences))),span))))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot use a logical Not on a value of non-boolean type"sv),span))));
 }
-if (MUST((((*this).is_scope_directly_accessible_from(current_scope_id,initial_scope_id))))){
-break;
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,expr_type_id))));
 }
-JaktInternal::Optional<types::ScopeId> const parent = ((scope)->parent);
-if ((!(((parent).has_value())))){
-break;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 10: {
+{
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,expr_type_id))));
 }
-(current_scope_id = (parent.value()));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::TypeCast>();
+types::CheckedTypeCast const& cast = __jakt_match_value.value;
+{
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,((cast).type_id())))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 4: {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(((aliased_namespaces).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (TRY((((*this).typecheck_unary_negate(checked_expr,span,expr_type_id)))));
 }
-size_t i = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 12: {
 {
-MUST((((resolved_namespaces).push(((aliased_namespaces)[(JaktInternal::checked_sub<size_t>(i,static_cast<size_t>(1ULL)))])))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 13: {
+{
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 14: {
+{
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 6: {
+{
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::RawPtr>(expr_type_id)))))))))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 7: {
+{
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Reference>(expr_type_id)))))))))));
 }
-((namespaces).shrink(static_cast<size_t>(0ULL)));
-MUST((((namespaces).push_values(((resolved_namespaces))))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 8: {
+{
+if ((!(((checked_expr)->is_mutable(((*this).program)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot make mutable reference to immutable value"sv),span))));
 }
-
-});
-JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const maybe_var = TRY((((*this).find_var_in_scope(current_scope_id,((call).name)))));
-if (((maybe_var).has_value())){
-types::TypeId const inner_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<JaktInternal::DynamicArray<types::FunctionId>>>{
-auto&& __jakt_match_variant = *((*this).get_type((((maybe_var.value()))->type_id)));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::MutableReference>(expr_type_id)))))))))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 5: {
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *expr_type;
 switch(__jakt_match_variant.index()) {
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
+types::TypeId const& type_id = __jakt_match_value.value;
+{
+if (((safety_mode).index() == 0 /* Safe */)){
+TRY((((*this).error(Jakt::DeprecatedString("Dereference of raw pointer outside of unsafe block"sv),span))));
+}
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,type_id))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
 case 27: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
 types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(type_id);
+{
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,type_id))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 28: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
 types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(type_id);
+{
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,type_id))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue((((maybe_var.value()))->type_id));
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Dereference of a non-pointer type ‘{}’"sv),TRY((((*this).type_name(expr_type_id,false))))))),span))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-if (((((*this).get_type(inner_type)))->index() == 29 /* Function */)){
-types::FunctionId const pseudo_function_id = ((((*this).get_type(inner_type)))->get<types::Type::Function>()).pseudo_function_id;
-return ((TRY((DynamicArray<types::FunctionId>::create_with({pseudo_function_id})))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,expr_type_id))));
 }
-JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>> const maybe_overload_set = TRY((((*this).find_scoped_functions_with_name_in_scope(current_scope_id,((call).name)))));
-if (((maybe_overload_set).has_value())){
-NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function((((((maybe_overload_set.value())).template get<0>()))[static_cast<i64>(0LL)])));
-if (((!(must_be_enum_constructor)) || ((((function)->type)).index() == 3 /* ImplicitEnumConstructor */))){
-(owning_scope = ((function)->owner_scope));
-(current_scope_id = (((maybe_overload_set.value())).template get<1>()));
-return ((((maybe_overload_set.value())).template get<0>()));
 }
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::infer_unsigned_int(u64 const val,utility::Span const span,JaktInternal::Optional<types::TypeId> const type_hint) {
+{
+NonnullRefPtr<typename types::CheckedExpression> expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } ))));
+if (((type_hint).has_value())){
+types::TypeId const hint = (type_hint.value());
+if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((((type_)->max()) < val)){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
-if (must_be_enum_constructor){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("No such enum constructor ‘{}’"sv),((call).name)))),span))));
-return ((TRY((DynamicArray<types::FunctionId>::create_with({})))));
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I8((infallible_integer_cast<i8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))));
 }
-JaktInternal::Optional<types::StructId> const maybe_struct_id = TRY((((*this).find_struct_in_scope(current_scope_id,((call).name)))));
-if (((maybe_struct_id).has_value())){
-types::StructId const struct_id = (maybe_struct_id.value());
-types::CheckedStruct const structure = ((*this).get_struct(struct_id));
-JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>> const maybe_function_id = TRY((((*this).find_scoped_functions_with_name_in_scope(((structure).scope_id),((structure).name)))));
-if (((maybe_function_id).has_value())){
-(current_scope_id = (((maybe_function_id.value())).template get<1>()));
-return ((((maybe_function_id.value())).template get<0>()));
+
+}
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((((type_)->max()) < val)){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I16((infallible_integer_cast<i16>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))));
 }
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Call to unknown function: ‘{}’"sv),((call).name)))),span))));
-return ((TRY((DynamicArray<types::FunctionId>::create_with({})))));
+
+}
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((((type_)->max()) < val)){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I32((infallible_integer_cast<i32>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))));
 }
 
-ErrorOr<typechecker::Typechecker> typechecker::Typechecker::typecheck(NonnullRefPtr<compiler::Compiler> compiler,parser::ParsedNamespace const parsed_namespace) {
-{
-JaktInternal::Optional<utility::FileId> const input_file = ((compiler)->current_file);
-if ((!(((input_file).has_value())))){
-TRY((((compiler)->panic(Jakt::DeprecatedString("trying to typecheck a non-existant file"sv)))));
 }
-DeprecatedString const true_module_name = TRY((((((((compiler)->files))[(((input_file.value())).id)])).basename(true))));
-types::ModuleId const placeholder_module_id = types::ModuleId(static_cast<size_t>(0ULL));
-DeprecatedString const root_module_name = TRY(((((((compiler)->current_file_path()).value())).basename(true))));
-typechecker::Typechecker typechecker = typechecker::Typechecker(compiler,TRY((types::CheckedProgram::__jakt_create(compiler,(TRY((DynamicArray<NonnullRefPtr<types::Module>>::create_with({})))),(TRY((Dictionary<DeprecatedString, types::LoadedModule>::create_with_entries({}))))))),placeholder_module_id,types::TypeId::none(),JaktInternal::OptionalNone(),false,static_cast<size_t>(0ULL),false,((compiler)->dump_type_hints),((compiler)->dump_try_hints),static_cast<u64>(0ULL),types::GenericInferences((TRY((Dictionary<DeprecatedString, DeprecatedString>::create_with_entries({}))))),JaktInternal::OptionalNone(),root_module_name,false,false);
-TRY((((typechecker).include_prelude())));
-types::ModuleId const root_module_id = TRY((((typechecker).create_module(root_module_name,true,JaktInternal::OptionalNone()))));
-(((typechecker).current_module_id) = root_module_id);
-((compiler)->set_current_file((input_file.value())));
-types::LoadedModule const loaded_module = types::LoadedModule(root_module_id,(input_file.value()));
-TRY((((((typechecker).program))->set_loaded_module(true_module_name,loaded_module))));
-types::ScopeId const PRELUDE_SCOPE_ID = ((typechecker).prelude_scope_id());
-types::ScopeId const root_scope_id = TRY((((typechecker).create_scope(PRELUDE_SCOPE_ID,false,Jakt::DeprecatedString("root"sv),false))));
-TRY((((typechecker).typecheck_module_import(parser::ParsedModuleImport( parser::ImportName { typename parser::ImportName::Literal(Jakt::DeprecatedString("jakt::prelude::prelude"sv),utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL))) } ,JaktInternal::OptionalNone(), parser::ImportList { typename parser::ImportList::All() } ),root_scope_id))));
-TRY((((typechecker).typecheck_module(parsed_namespace,root_scope_id))));
-return (typechecker);
-}
-}
-
-ErrorOr<bool> typechecker::Typechecker::add_enum_to_scope(types::ScopeId const scope_id,DeprecatedString const name,types::EnumId const enum_id,utility::Span const span) {
-{
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::EnumId> const maybe_enum_id = ((((scope)->enums)).get(name));
-if (((maybe_enum_id).has_value())){
-types::EnumId const existing_enum_id = (maybe_enum_id.value());
-utility::Span const definition_span = ((((*this).get_enum(existing_enum_id))).name_span);
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("redefinition of enum {}"sv),name))),span,TRY((__jakt_format(Jakt::DeprecatedString("enum {} was first defined here"sv),name))),definition_span))));
-return (false);
-}
-TRY((((((scope)->enums)).set(name,enum_id))));
-return (true);
-}
-}
-
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> typechecker::Typechecker::find_scoped_functions_with_name_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
-{
-return (TRY((((((*this).program))->find_scoped_functions_with_name_in_scope(parent_scope_id,function_name)))));
-}
-}
-
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_if(NonnullRefPtr<typename parser::ParsedExpression> const condition,parser::ParsedBlock const then_block,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const else_statement,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
-{
-JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const new_condition_new_then_block_new_else_statement_ = TRY((((*this).expand_context_for_bindings(condition,JaktInternal::OptionalNone(),then_block,else_statement,span))));
-NonnullRefPtr<typename parser::ParsedExpression> const new_condition = ((new_condition_new_then_block_new_else_statement_).template get<0>());
-JaktInternal::Optional<parser::ParsedBlock> const new_then_block = ((new_condition_new_then_block_new_else_statement_).template get<1>());
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const new_else_statement = ((new_condition_new_then_block_new_else_statement_).template get<2>());
-
-NonnullRefPtr<typename types::CheckedExpression> const checked_condition = TRY((((*this).typecheck_expression_and_dereference_if_needed(new_condition,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-if ((!(((((checked_condition)->type())).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
-TRY((((*this).error(Jakt::DeprecatedString("Condition must be a boolean expression"sv),((new_condition)->span())))));
-}
-types::CheckedBlock const checked_block = TRY((((*this).typecheck_block((new_then_block.value()),scope_id,safety_mode,JaktInternal::OptionalNone()))));
-if (((((checked_block).yielded_type)).has_value())){
-TRY((((*this).error(Jakt::DeprecatedString("An 'if' block is not allowed to yield values"sv),((((new_then_block.value())).find_yield_span()).value())))));
-}
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> checked_else = JaktInternal::OptionalNone();
-if (((new_else_statement).has_value())){
-(checked_else = TRY((((*this).typecheck_statement((new_else_statement.value()),scope_id,safety_mode,JaktInternal::OptionalNone())))));
-}
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::If>(checked_condition,checked_block,checked_else,span))));
-}
-}
-
-ErrorOr<types::CheckedVisibility> typechecker::Typechecker::typecheck_visibility(parser::Visibility const visibility,types::ScopeId const scope_id) {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedVisibility, ErrorOr<types::CheckedVisibility>>{
-auto&& __jakt_match_variant = visibility;
-switch(__jakt_match_variant.index()) {
-case 1: {
-return JaktInternal::ExplicitValue( types::CheckedVisibility { typename types::CheckedVisibility::Private() } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::CheckedVisibility { typename types::CheckedVisibility::Public() } );
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::Visibility::Restricted>();JaktInternal::DynamicArray<parser::VisibilityRestriction> const& whitelist = __jakt_match_value.whitelist;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::CheckedVisibility> __jakt_var_452; {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> restricted_scopes = (TRY((DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>>::create_with({}))));
-{
-JaktInternal::ArrayIterator<parser::VisibilityRestriction> _magic = ((whitelist).iterator());
-for (;;){
-JaktInternal::Optional<parser::VisibilityRestriction> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::VisibilityRestriction entry = (_magic_value.value());
-{
-NonnullRefPtr<typename types::MaybeResolvedScope> parent_scope = TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Resolved>(scope_id)));
-{
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((entry).namespace_)).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-DeprecatedString ns = (_magic_value.value());
-{
-(parent_scope = TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Unresolved>(parent_scope,ns))));
-}
-
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((((type_)->max()) < val)){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8((infallible_integer_cast<u8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))));
 }
 
-NonnullRefPtr<typename types::MaybeResolvedScope> unresolved = TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Unresolved>(parent_scope,((entry).name))));
-TRY((((restricted_scopes).push(TRY((((unresolved)->try_resolve(((*this).program)))))))));
 }
-
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((((type_)->max()) < val)){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U16((infallible_integer_cast<u16>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))));
 }
 
-__jakt_var_452 =  types::CheckedVisibility { typename types::CheckedVisibility::Restricted(restricted_scopes,span) } ; goto __jakt_label_415;
-
-}
-__jakt_label_415:; __jakt_var_452.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
 }
-}
-
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_destructuring_assignment(JaktInternal::DynamicArray<parser::ParsedVarDecl> const vars,NonnullRefPtr<typename parser::ParsedStatement> const var_decl,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
-{
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> var_decls = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
-NonnullRefPtr<typename types::CheckedStatement> const checked_tuple_var_decl = TRY((((*this).typecheck_statement(var_decl,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-types::TypeId expr_type_id = types::unknown_type_id();
-types::VarId tuple_var_id = types::VarId(types::ModuleId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL));
-if (((checked_tuple_var_decl)->index() == 3 /* VarDecl */)){
-types::VarId const var_id = ((checked_tuple_var_decl)->get<types::CheckedStatement::VarDecl>()).var_id;
-NonnullRefPtr<typename types::CheckedExpression> const init = ((checked_tuple_var_decl)->get<types::CheckedStatement::VarDecl>()).init;
-(expr_type_id = ((init)->type()));
-(tuple_var_id = var_id);
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((((type_)->max()) < val)){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Destructuting assignment should be a variable declaration"sv),span))));
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U32((infallible_integer_cast<u32>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))));
 }
 
-JaktInternal::DynamicArray<types::TypeId> inner_types = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-NonnullRefPtr<typename types::Type> const tuple_type = ((*this).get_type(expr_type_id));
-if (((tuple_type)->index() == 19 /* GenericInstance */)){
-JaktInternal::DynamicArray<types::TypeId> const args = ((tuple_type)->get<types::Type::GenericInstance>()).args;
-(inner_types = args);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Tuple Type should be Generic Instance"sv),span))));
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))){
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U64((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))));
 }
-
-NonnullRefPtr<types::CheckedVariable> const tuple_variable = ((((*this).program))->get_variable(tuple_var_id));
-if ((((vars).size()) == ((inner_types).size()))){
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((vars).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))){
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))));
 }
-size_t i = (_magic_value.value());
-{
-parser::ParsedVarDecl new_var = ((vars)[i]);
-(((new_var).parsed_type) = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Name>(TRY((((*this).type_name(((inner_types)[i]),false)))),span))));
-NonnullRefPtr<typename parser::ParsedExpression> const init = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedTuple>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(((tuple_variable)->name),span))),i,false,span)));
-TRY((((var_decls).push(TRY((((*this).typecheck_var_decl(((vars)[i]),init,scope_id,safety_mode,span))))))));
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } )))){
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } )))));
 }
-
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((val > static_cast<u64>(255ULL))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8((infallible_integer_cast<u8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } )))));
 }
 
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Tuple inner types sould have same size as tuple members"sv),span))));
 }
-
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::DestructuringAssignment>(var_decls,checked_tuple_var_decl,span))));
+return (expr);
 }
 }
 
-types::ScopeId typechecker::Typechecker::prelude_scope_id() const {
+ErrorOr<types::TypeId> typechecker::Typechecker::strip_optional_from_type(types::TypeId const type_id) {
 {
-return (((((*this).program))->prelude_scope_id()));
-}
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<types::TypeId>>{
+auto&& __jakt_match_variant = *((*this).get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_443; {
+if (((id).equals(TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))))))){
+return (((args)[static_cast<i64>(0LL)]));
 }
+__jakt_var_443 = type_id; goto __jakt_label_409;
 
-ErrorOr<JaktInternal::Optional<types::TypeId>> typechecker::Typechecker::find_type_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
-{
-return (((TRY((((*this).find_type_scope(scope_id,name))))).map([](auto& _value) { return _value.template get<0>(); })));
+}
+__jakt_label_409:; __jakt_var_443.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(type_id);
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
@@ -5582,110 +5539,118 @@ return (JaktInternal::OptionalNone());
 }
 }
 
-ErrorOr<types::ScopeId> typechecker::Typechecker::create_scope(JaktInternal::Optional<types::ScopeId> const parent_scope_id,bool const can_throw,DeprecatedString const debug_name,bool const for_block) {
+ErrorOr<types::CheckedParameter> typechecker::Typechecker::typecheck_parameter(parser::ParsedParameter const parameter,types::ScopeId const scope_id,bool const first,JaktInternal::Optional<types::TypeId> const this_arg_type_id,JaktInternal::Optional<types::ScopeId> const check_scope) {
 {
-return (TRY((((((*this).program))->create_scope(parent_scope_id,can_throw,debug_name,((*this).current_module_id),for_block)))));
+types::TypeId type_id = TRY((((*this).typecheck_typename(((((parameter).variable)).parsed_type),scope_id,((((parameter).variable)).name)))));
+if ((first && (((((parameter).variable)).name) == Jakt::DeprecatedString("this"sv)))){
+if (((this_arg_type_id).has_value())){
+(type_id = (this_arg_type_id.value()));
 }
 }
-
-types::CheckedEnum typechecker::Typechecker::get_enum(types::EnumId const id) const {
-{
-return (((((*this).program))->get_enum(id)));
+NonnullRefPtr<types::CheckedVariable> const variable = TRY((types::CheckedVariable::__jakt_create(((((parameter).variable)).name),type_id,((((parameter).variable)).is_mutable),((((parameter).variable)).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_default_value = JaktInternal::OptionalNone();
+if (((((parameter).default_argument)).has_value())){
+NonnullRefPtr<typename types::CheckedExpression> checked_default_value_expr = TRY((((*this).typecheck_expression((((parameter).default_argument).value()),scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,type_id))));
+if (((checked_default_value_expr)->index() == 25 /* OptionalNone */)){
+utility::Span const expr_span = ((checked_default_value_expr)->get<types::CheckedExpression::OptionalNone>()).span;
+(checked_default_value_expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::OptionalNone>(expr_span,type_id))));
+}
+types::TypeId const default_value_type_id = ((checked_default_value_expr)->type());
+(checked_default_value = checked_default_value_expr);
+if ((!(TRY((((*this).check_types_for_compat(type_id,default_value_type_id,((((*this).generic_inferences))),((checked_default_value_expr)->span())))))))){
+(checked_default_value = JaktInternal::OptionalNone());
+}
+}
+types::CheckedParameter const checked_parameter = types::CheckedParameter(((parameter).requires_label),variable,checked_default_value);
+if (((check_scope).has_value())){
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::VarId const var_id = TRY((((module)->add_variable(variable))));
+TRY((((*this).add_var_to_scope((check_scope.value()),((((parameter).variable)).name),var_id,((((parameter).variable)).span)))));
+}
+return (checked_parameter);
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_try_block(NonnullRefPtr<typename parser::ParsedStatement> const stmt,DeprecatedString const error_name,utility::Span const error_span,parser::ParsedBlock const catch_block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+ErrorOr<JaktInternal::Optional<types::TypeId>> typechecker::Typechecker::unify(types::TypeId const lhs,utility::Span const lhs_span,types::TypeId const rhs,utility::Span const rhs_span) {
 {
-types::ScopeId const try_scope_id = TRY((((*this).create_scope(scope_id,true,Jakt::DeprecatedString("try"sv),true))));
-NonnullRefPtr<typename types::CheckedStatement> const checked_stmt = TRY((((*this).typecheck_statement(stmt,try_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-types::StructId const error_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
-NonnullRefPtr<types::CheckedVariable> const error_decl = TRY((types::CheckedVariable::__jakt_create(error_name,((((*this).get_struct(error_struct_id))).type_id),false,error_span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::VarId const error_id = TRY((((module)->add_variable(error_decl))));
-NonnullRefPtr<types::Scope> const parent_scope = TRY((((*this).get_scope(scope_id))));
-types::ScopeId const catch_scope_id = TRY((((*this).create_scope(scope_id,((parent_scope)->can_throw),Jakt::DeprecatedString("catch"sv),true))));
-TRY((((*this).add_var_to_scope(catch_scope_id,error_name,error_id,error_span))));
-types::CheckedBlock const checked_catch_block = TRY((((*this).typecheck_block(catch_block,catch_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-if (((((checked_catch_block).yielded_type)).has_value())){
-TRY((((*this).error(Jakt::DeprecatedString("A ‘catch’ block as part of a try block is not allowed to yield values"sv),(((catch_block).find_yield_span()).value())))));
+if ((!(TRY((((*this).check_types_for_compat(lhs,rhs,((((*this).generic_inferences))),lhs_span))))))){
+return (JaktInternal::OptionalNone());
 }
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::TryBlock>(checked_stmt,checked_catch_block,error_name,error_span,span,types::void_type_id()))));
+return (TRY((((*this).substitute_typevars_in_type(lhs,((*this).generic_inferences))))));
 }
 }
 
-ErrorOr<types::CheckedUnaryOperator> typechecker::Typechecker::typecheck_is_enum_variant(NonnullRefPtr<typename types::CheckedExpression> const checked_expr,NonnullRefPtr<typename parser::ParsedType> const inner,JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const bindings,types::ScopeId const scope_id) {
+types::BlockControlFlow typechecker::Typechecker::maybe_statement_control_flow(JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const statement,types::BlockControlFlow const other_branch) const {
 {
-bool const old_ignore_errors = ((*this).ignore_errors);
-(((*this).ignore_errors) = true);
-types::TypeId const type_id = TRY((((*this).typecheck_typename(inner,scope_id,JaktInternal::OptionalNone()))));
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
-types::CheckedUnaryOperator checked_op =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Is(type_id) } ;
-types::TypeId const expr_type_id = ((checked_expr)->type());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<types::CheckedUnaryOperator>>{
-auto&& __jakt_match_variant = *inner;
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& variant_name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-{
-if (((((*this).get_type(expr_type_id)))->index() == 24 /* Enum */)){
-types::EnumId const enum_id = ((((*this).get_type(expr_type_id)))->get<types::Type::Enum>()).value;
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-JaktInternal::Optional<types::CheckedEnumVariant> const variant = TRY((((*this).get_enum_variant(enum_,variant_name))));
-if (((variant).has_value())){
-JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>> const checked_enum_variant_bindings = TRY((((*this).typecheck_enum_variant_bindings((variant.value()),bindings,span))));
-(checked_op =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::IsEnumVariant((variant.value()),(checked_enum_variant_bindings.value()),expr_type_id) } );
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
+auto __jakt_enum_value = (((statement).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((*this).statement_control_flow((statement.value()))));
 }
 else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist on {}"sv),variant_name,TRY((((*this).type_name(type_id,false))))))),span))));
-return (checked_op);
+return JaktInternal::ExplicitValue(((other_branch).partial()));
+}
+}()))
+);
+}
 }
 
+bool typechecker::Typechecker::is_floating(types::TypeId const type_id) const {
+{
+return (((((*this).program))->is_floating(type_id)));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),variant_name))),span))));
-return (checked_op);
 }
 
+ErrorOr<JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>>> typechecker::Typechecker::find_var_in_scope(types::ScopeId const scope_id,DeprecatedString const var) const {
+{
+return (TRY((((((*this).program))->find_var_in_scope(scope_id,var)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& variant_name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+}
+
+ErrorOr<void> typechecker::Typechecker::set_owner_scope_if_needed(types::ScopeId const parent_scope_id,JaktInternal::DynamicArray<types::FunctionId> const overload_set) {
 {
-if (((((*this).get_type(expr_type_id)))->index() == 24 /* Enum */)){
-types::EnumId const enum_id = ((((*this).get_type(expr_type_id)))->get<types::Type::Enum>()).value;
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-JaktInternal::Optional<types::CheckedEnumVariant> const variant = TRY((((*this).get_enum_variant(enum_,variant_name))));
-if (((variant).has_value())){
-JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>> const checked_enum_variant_bindings = TRY((((*this).typecheck_enum_variant_bindings((variant.value()),bindings,span))));
-(checked_op =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::IsEnumVariant((variant.value()),(checked_enum_variant_bindings.value()),expr_type_id) } );
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::FunctionId overload = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedFunction> function = ((*this).get_function(overload));
+if ((!(((((function)->owner_scope)).has_value())))){
+(((function)->owner_scope) = parent_scope_id);
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist on {}"sv),variant_name,TRY((((*this).type_name(type_id,false))))))),span))));
-return (checked_op);
 }
 
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),variant_name))),span))));
-return (checked_op);
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+return {};
+}
+
+ErrorOr<void> typechecker::Typechecker::set_owner_scope_if_needed(types::ScopeId const parent_scope_id,types::VarId const var_id) {
 {
+NonnullRefPtr<types::CheckedVariable> variable = ((*this).get_variable(var_id));
+if ((!(((((variable)->owner_scope)).has_value())))){
+(((variable)->owner_scope) = parent_scope_id);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-return (checked_op);
+}
+return {};
+}
+
+ErrorOr<bool> typechecker::Typechecker::add_type_to_scope(types::ScopeId const scope_id,DeprecatedString const type_name,types::TypeId const type_id,utility::Span const span) {
+{
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::TypeId> const found_type_id = ((((scope)->types)).get(type_name));
+if ((((found_type_id).has_value()) && (!((((found_type_id.value())).equals(type_id)))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of type ‘{}’"sv),type_name))),span))));
+return (false);
+}
+TRY((((((scope)->types)).set(type_name,type_id))));
+return (true);
 }
 }
 
@@ -5700,164 +5665,131 @@ TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("int
 }
 }
 
-types::TypeId typechecker::Typechecker::infer_function_return_type(types::CheckedBlock const block) const {
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::infer_signed_int(i64 const val,utility::Span const span,JaktInternal::Optional<types::TypeId> const type_hint) {
 {
-if (((((block).statements)).is_empty())){
-return (types::void_type_id());
+NonnullRefPtr<typename types::CheckedExpression> expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } ))));
+if (((type_hint).has_value())){
+types::TypeId const hint = (type_hint.value());
+if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
-if ((((((((block).statements)).last()).value()))->index() == 8 /* Return */)){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const val = (((((((block).statements)).last()).value()))->get<types::CheckedStatement::Return>()).val;
-if (((val).has_value())){
-return ((((val.value()))->type()));
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I8((infallible_integer_cast<i8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))));
 }
+
 }
-return (types::void_type_id());
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I16((infallible_integer_cast<i16>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))));
 }
 
-ErrorOr<JaktInternal::Optional<types::Value>> typechecker::Typechecker::find_comptime_binding_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
-{
-return (TRY((((((*this).program))->find_comptime_binding_in_scope(scope_id,name)))));
 }
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+}
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I32((infallible_integer_cast<i32>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))));
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_statement(NonnullRefPtr<typename parser::ParsedStatement> const statement,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedStatement>, ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
-auto&& __jakt_match_variant = *statement;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Expression>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Expression>(TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,types::TypeId::none())))),span))));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::UnsafeBlock>();parser::ParsedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Block>(TRY((((*this).typecheck_block(block,scope_id, types::SafetyMode { typename types::SafetyMode::Unsafe() } ,JaktInternal::OptionalNone())))),span))));
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Yield>(TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,type_hint)))),span))));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Return>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_return(expr,span,scope_id,safety_mode)))));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Block>();parser::ParsedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_block_statement(block,scope_id,safety_mode,span)))));
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::InlineCpp>();parser::ParsedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_inline_cpp(block,span,safety_mode)))));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Defer>();NonnullRefPtr<typename parser::ParsedStatement> const& statement = __jakt_match_value.statement;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_defer(statement,scope_id,safety_mode,span)))));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Loop>();parser::ParsedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_loop(block,scope_id,safety_mode,span)))));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Throw>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_throw(expr,scope_id,safety_mode,span)))));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::While>();NonnullRefPtr<typename parser::ParsedExpression> const& condition = __jakt_match_value.condition;
-parser::ParsedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_while(condition,block,scope_id,safety_mode,span)))));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Continue>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Continue>(span))));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Break>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Break>(span))));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::VarDecl>();parser::ParsedVarDecl const& var = __jakt_match_value.var;
-NonnullRefPtr<typename parser::ParsedExpression> const& init = __jakt_match_value.init;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_var_decl(var,init,scope_id,safety_mode,span)))));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::DestructuringAssignment>();JaktInternal::DynamicArray<parser::ParsedVarDecl> const& vars = __jakt_match_value.vars;
-NonnullRefPtr<typename parser::ParsedStatement> const& var_decl = __jakt_match_value.var_decl;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_destructuring_assignment(vars,var_decl,scope_id,safety_mode,span)))));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::If>();NonnullRefPtr<typename parser::ParsedExpression> const& condition = __jakt_match_value.condition;
-parser::ParsedBlock const& then_block = __jakt_match_value.then_block;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const& else_statement = __jakt_match_value.else_statement;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_if(condition,then_block,else_statement,scope_id,safety_mode,span)))));
-};/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedStatement::Garbage>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Garbage>(span))));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::For>();DeprecatedString const& iterator_name = __jakt_match_value.iterator_name;
-utility::Span const& name_span = __jakt_match_value.name_span;
-bool const& is_destructuring = __jakt_match_value.is_destructuring;
-NonnullRefPtr<typename parser::ParsedExpression> const& range = __jakt_match_value.range;
-parser::ParsedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_for(iterator_name,name_span,is_destructuring,range,block,scope_id,safety_mode,span)))));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-parser::ParsedBlock const& else_block = __jakt_match_value.else_block;
-parser::ParsedBlock const& remaining_code = __jakt_match_value.remaining_code;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_guard(expr,else_block,remaining_code,scope_id,safety_mode,span)))));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
 }
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+}
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8((infallible_integer_cast<u8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))));
 }
 
-ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>>> typechecker::Typechecker::resolve_default_params(JaktInternal::DynamicArray<types::CheckedParameter> const params,JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const args,types::ScopeId const scope_id,types::SafetyMode const safety_mode,size_t const arg_offset,utility::Span const span) {
-{
-size_t params_with_default_value = static_cast<size_t>(0ULL);
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((params).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::CheckedParameter param = (_magic_value.value());
-{
-if (((((param).default_value)).has_value())){
-((params_with_default_value++));
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U16((infallible_integer_cast<u16>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))));
 }
 
 }
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+}
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U32((infallible_integer_cast<u32>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))));
 }
 
-if (((((args).size()) >= (JaktInternal::checked_sub<size_t>((JaktInternal::checked_sub<size_t>(((params).size()),arg_offset)),params_with_default_value))) && (((args).size()) <= (JaktInternal::checked_sub<size_t>(((params).size()),arg_offset))))){
-size_t consumed_arg = static_cast<size_t>(0ULL);
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>> resolved_args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
+}
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((val < static_cast<i64>(0LL))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+}
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U64((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))));
+}
+
+}
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((val < static_cast<i64>(0LL))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+}
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))));
+}
+
+}
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if ((val < static_cast<i64>(0LL))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+}
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } )))));
+}
+
+}
+else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } )))){
+types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } );
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
+if (((val < static_cast<i64>(0LL)) || (val > static_cast<i64>(255LL)))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+}
+else {
+(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8((infallible_integer_cast<u8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } )))));
+}
+
+}
+}
+return (expr);
+}
+}
+
+ErrorOr<void> typechecker::Typechecker::typecheck_namespace_aliases(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id,typechecker::ImportRestrictions const allow) {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(arg_offset),static_cast<size_t>(((params).size()))});
+JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
 for (;;){
 JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
@@ -5865,1439 +5797,1170 @@ break;
 }
 size_t i = (_magic_value.value());
 {
-types::CheckedParameter const param = ((params)[i]);
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> maybe_checked_expr = JaktInternal::OptionalNone();
-if ((!(((param).requires_label)))){
-if ((((args).size()) <= consumed_arg)){
-if ((!(((((param).default_value)).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Missing argument for function parameter {}"sv),((((param).variable))->name)))),span))));
-continue;
-}
-(maybe_checked_expr = ((param).default_value));
+parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
+types::ScopeId const child_namespace_scope_id = ((children)[i]);
+TRY((((*this).typecheck_namespace_aliases(child_namespace,child_namespace_scope_id,allow))));
 }
-else {
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const name_span_expr_ = ((args)[consumed_arg]);
-DeprecatedString const name = ((name_span_expr_).template get<0>());
-utility::Span const span = ((name_span_expr_).template get<1>());
-NonnullRefPtr<typename parser::ParsedExpression> const expr = ((name_span_expr_).template get<2>());
 
-if (((!(((name).is_empty()))) && (name != ((((param).variable))->name)))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Wrong parameter name in argument label (got '{}', expected '{}')"sv),name,((((param).variable))->name)))),span))));
 }
-(maybe_checked_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,((((param).variable))->type_id))))));
-((consumed_arg++));
 }
 
+{
+JaktInternal::ArrayIterator<parser::ParsedAlias> _magic = ((((parsed_namespace).aliases)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedAlias> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-(maybe_checked_expr = ((param).default_value));
-if ((((args).size()) > consumed_arg)){
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const name_span_expr_ = ((args)[consumed_arg]);
-DeprecatedString const name = ((name_span_expr_).template get<0>());
-utility::Span const span = ((name_span_expr_).template get<1>());
-NonnullRefPtr<typename parser::ParsedExpression> const expr = ((name_span_expr_).template get<2>());
-
-if (TRY((((*this).validate_argument_label(param,name,span,expr,maybe_checked_expr))))){
-(maybe_checked_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,((((param).variable))->type_id))))));
-((consumed_arg++));
+parser::ParsedAlias alias = (_magic_value.value());
+{
+TRY((((*this).typecheck_alias(alias,scope_id,allow))));
 }
+
 }
 }
 
-if (((maybe_checked_expr).has_value())){
-NonnullRefPtr<typename types::CheckedExpression> checked_arg = (maybe_checked_expr.value());
-TRY((((resolved_args).push((Tuple{((((param).variable))->name), span, checked_arg})))));
 }
+return {};
 }
 
+ErrorOr<bool> typechecker::Typechecker::add_struct_to_scope(types::ScopeId const scope_id,DeprecatedString const name,types::StructId const struct_id,utility::Span const span) {
+{
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::StructId> const maybe_scope_id = ((((scope)->structs)).get(name));
+if (((maybe_scope_id).has_value())){
+types::StructId const existing_struct_id = (maybe_scope_id.value());
+utility::Span const definition_span = ((((*this).get_struct(existing_struct_id))).name_span);
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("redefinition of struct/class {}"sv),name))),span,TRY((__jakt_format(Jakt::DeprecatedString("struct/class {} was first defined here"sv),name))),definition_span))));
+return (false);
+}
+TRY((((((scope)->structs)).set(name,struct_id))));
+return (true);
 }
 }
 
-return (resolved_args);
+ErrorOr<void> typechecker::Typechecker::error(DeprecatedString const message,utility::Span const span) {
+{
+if ((!(((*this).ignore_errors)))){
+TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::Message(message,span) } ))));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Wrong number of arguments"sv),span))));
-return ((TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({})))));
+(((*this).had_an_error) = true);
 }
 
 }
+return {};
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_expression(NonnullRefPtr<typename parser::ParsedExpression> const expr,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
+ErrorOr<bool> typechecker::Typechecker::check_restricted_access(types::ScopeId const accessor,DeprecatedString const accessee_kind,types::ScopeId const accessee,DeprecatedString const name,JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> const whitelist,utility::Span const span) {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *expr;
+types::ScopeId const most_specific_active_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId,ErrorOr<bool>>{
+auto __jakt_enum_value = (((((*this).current_function_id)).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((((*this).get_function((((*this).current_function_id).value()))))->function_scope_id));
+}
+else {
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_444; {
+if ((!(((((*this).current_struct_type_id)).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't access {0} ‘{1}’ from this global scope, because ‘{1}’ restricts access to it"sv),accessee_kind,name))),span))));
+return (false);
+}
+__jakt_var_444 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId, ErrorOr<bool>>{
+auto&& __jakt_match_variant = *((*this).get_type((((*this).current_struct_type_id).value())));
 switch(__jakt_match_variant.index()) {
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedStruct>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-DeprecatedString const& field_name = __jakt_match_value.field_name;
-utility::Span const& span = __jakt_match_value.span;
-bool const& is_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_struct(expr,field_name,scope_id,is_optional,safety_mode,span)))));
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((*this).get_struct(id))).scope_id));
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ComptimeIndex>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-NonnullRefPtr<typename parser::ParsedExpression> const& index = __jakt_match_value.index;
-utility::Span const& span = __jakt_match_value.span;
-bool const& is_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_comptime_index(expr,index,scope_id,is_optional,safety_mode,span)))));
+default: {
+{
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Internal error: current_struct_type_id is not a struct"sv),span))));
+}
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Boolean>();bool const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_453; {
-TRY((((*this).unify_with_type(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ),type_hint,span))));
-__jakt_var_453 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Boolean>(val,span))); goto __jakt_label_416;
+}/*switch end*/
+}()
+)); goto __jakt_label_410;
 
 }
-__jakt_label_416:; __jakt_var_453.release_value(); }));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NumericConstant>();parser::NumericConstant const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_454; {
-JaktInternal::Optional<types::TypeId> type_hint_unwrapped = type_hint;
-if ((((type_hint).has_value()) && ((((*this).get_type((type_hint.value()))))->index() == 19 /* GenericInstance */))){
-types::StructId const id = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).args;
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-if (((id).equals(optional_struct_id))){
-(type_hint_unwrapped = ((args)[static_cast<i64>(0LL)]));
+__jakt_label_410:; __jakt_var_444.release_value(); }));
 }
+}()))
+;
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::MaybeResolvedScope>> _magic = ((whitelist).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::MaybeResolvedScope>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_var_454 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = val;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I8>();
-i8 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I8(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I16>();
-i16 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I16(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I32>();
-i32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I32(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I64>();
-i64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } )))));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U8>();
-u8 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U16>();
-u16 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U16(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U32>();
-u32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U32(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U64>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::USize>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::F32>();
-f32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::F32(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::F32() } )))));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::F64>();
-f64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::F64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::F64() } )))));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::UnknownSigned>();
-i64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).infer_signed_int(val,span,type_hint_unwrapped)))));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::UnknownUnsigned>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).infer_unsigned_int(val,span,type_hint_unwrapped)))));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)); goto __jakt_label_417;
-
-}
-__jakt_label_417:; __jakt_var_454.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::SingleQuotedString>();DeprecatedString const& val = __jakt_match_value.val;
-JaktInternal::Optional<DeprecatedString> const& prefix = __jakt_match_value.prefix;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = (prefix.value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }));
-if (__jakt_enum_value == Jakt::DeprecatedString(""sv)) {
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::CharacterConstant>(val,span))));
-}
-else if (__jakt_enum_value == Jakt::DeprecatedString("b"sv)) {
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::ByteConstant>(val,span))));
+NonnullRefPtr<typename types::MaybeResolvedScope> scope = (_magic_value.value());
+{
+NonnullRefPtr<typename types::MaybeResolvedScope> const resolved_scope = TRY((((scope)->try_resolve(((*this).program)))));
+if (((resolved_scope)->index() == 0 /* Resolved */)){
+types::ScopeId const scope_id = ((resolved_scope)->get<types::MaybeResolvedScope::Resolved>()).value;
+if (TRY((((*this).scope_can_access(most_specific_active_scope_id,scope_id))))){
+return (true);
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("c"sv)) {
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::CCharacterConstant>(val,span))));
 }
 else {
-{
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("Unknown string prefix {}"sv),prefix)))))));
-}
+continue;
 }
-}()))
-);
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::QuotedString>();DeprecatedString const& val = __jakt_match_value.val;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_455; {
-if (((*this).dump_try_hints)){
-TRY((((*this).dump_try_hint(span))));
+
 }
-__jakt_var_455 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = ((((type_hint).has_value()) && (!((((type_hint.value())).equals(types::unknown_type_id()))))));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_456; {
-types::TypeId type_id = TRY((((*this).strip_optional_from_type(TRY((((((*this).generic_inferences)).map((type_hint.value())))))))));
-bool may_throw = true;
-if (((!(((type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ))))) && ((((*this).get_type(type_id)))->is_concrete()))){
-JaktInternal::Optional<typechecker::TraitImplementationDescriptor> const trait_implementation = TRY((((*this).find_any_singular_trait_implementation(type_id,(TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("FromStringLiteral"sv), Jakt::DeprecatedString("ThrowingFromStringLiteral"sv)})))),scope_id,span))));
-if ((!(((trait_implementation).has_value())))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type {} cannot be used as an overloaded string literal type"sv),TRY((((*this).type_name(type_id,false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("Consider implementing the FromStringLiteral trait for {}"sv),TRY((((*this).type_name(type_id,false))))))),span))));
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+
 }
-else {
-(may_throw = ((((trait_implementation.value())).trait_name) == Jakt::DeprecatedString("ThrowingFromStringLiteral"sv)));
 }
 
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(most_specific_active_scope_id))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot access {} ‘{}’ from this scope"sv),accessee_kind,name))),span))));
+return (false);
 }
-else if ((!(((((*this).get_type(type_id)))->is_concrete())))){
-(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
 }
-TRY((((*this).unify((type_hint.value()),span,type_id,span))));
-__jakt_var_456 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::QuotedString>(types::CheckedStringLiteral( types::StringLiteral { typename types::StringLiteral::Static(val) } ,type_id,may_throw),span))); goto __jakt_label_419;
 
+ErrorOr<bool> typechecker::Typechecker::check_types_for_compat(types::TypeId const lhs_type_id,types::TypeId const rhs_type_id,types::GenericInferences& generic_inferences,utility::Span const span) {
+{
+if (((((lhs_type_id).equals(rhs_type_id)) || ((lhs_type_id).equals(types::unknown_type_id()))) || ((rhs_type_id).equals(types::unknown_type_id())))){
+return (true);
 }
-__jakt_label_419:; __jakt_var_456.release_value(); }));
+NonnullRefPtr<typename types::Type> const lhs_type = ((*this).get_type(lhs_type_id));
+NonnullRefPtr<typename types::Type> const rhs_type = ((*this).get_type(rhs_type_id));
+if (((lhs_type)->index() == 30 /* Self */)){
+if ((!(((((*this).self_type_id)).has_value())))){
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of the 'Self' type"sv),span))));
 }
 else {
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::QuotedString>(types::CheckedStringLiteral( types::StringLiteral { typename types::StringLiteral::Static(val) } ,types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ),true),span))));
+return (TRY((((*this).check_types_for_compat((((*this).self_type_id).value()),rhs_type_id,generic_inferences,span)))));
 }
-}()))
-; goto __jakt_label_418;
 
 }
-__jakt_label_418:; __jakt_var_455.release_value(); }));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Call>();parser::ParsedCall const& call = __jakt_match_value.call;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_457; {
-__jakt_var_457 = TRY((((*this).typecheck_call(call,scope_id,span,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),safety_mode,type_hint,false)))); goto __jakt_label_420;
+if (((rhs_type)->index() == 30 /* Self */)){
+if ((!(((((*this).self_type_id)).has_value())))){
+TRY((((*this).error(Jakt::DeprecatedString("Invalid use of the 'Self' type"sv),span))));
+}
+else {
+return (TRY((((*this).check_types_for_compat(lhs_type_id,(((*this).self_type_id).value()),generic_inferences,span)))));
+}
 
 }
-__jakt_label_420:; __jakt_var_457.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::MethodCall>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-parser::ParsedCall const& call = __jakt_match_value.call;
-utility::Span const& span = __jakt_match_value.span;
-bool const& is_optional = __jakt_match_value.is_optional;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_458; {
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-types::TypeId const checked_expr_type_id = ((checked_expr)->type());
-bool found_optional = false;
-JaktInternal::Optional<types::StructLikeId> const parent_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(TRY((((*this).final_type_resolution_form(checked_expr_type_id,scope_id))))));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),id) } ));
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),id) } ));
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("String"sv)))))) } ));
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::StructLikeId>> __jakt_var_459; {
-__jakt_var_459 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = (is_optional);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::StructLikeId>> __jakt_var_460; {
+DeprecatedString const lhs_type_id_string = TRY((((lhs_type_id).to_string())));
+DeprecatedString const rhs_type_id_string = TRY((((rhs_type_id).to_string())));
 types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-JaktInternal::Optional<types::StructLikeId> struct_id = JaktInternal::OptionalNone();
-if ((!(((id).equals(optional_struct_id))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't use ‘{}’ as an optional type in optional chained call"sv),((((*this).get_struct(id))).name)))),span))));
+types::StructId const weakptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+types::StructId const array_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<bool>>{
+auto&& __jakt_match_variant = *lhs_type;
+switch(__jakt_match_variant.index()) {
+case 18: {
+{
+JaktInternal::Optional<DeprecatedString> seen_type_id_string = ((((generic_inferences))).get(lhs_type_id_string));
+if (((seen_type_id_string).has_value())){
+types::TypeId const seen_type_id = TRY((types::TypeId::from_string((seen_type_id_string.value()))));
+if (((((*this).get_type(seen_type_id)))->index() == 18 /* TypeVariable */)){
+return (TRY((((*this).check_types_for_compat(seen_type_id,lhs_type_id,generic_inferences,span)))));
+}
+if ((((seen_type_id_string).value()) != rhs_type_id_string)){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(seen_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
+}
 }
 else {
-(found_optional = true);
-(struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(((args)[static_cast<i64>(0LL)])));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } );
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue( types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } );
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),id) } );
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-return JaktInternal::ExplicitValue( types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),id) } );
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<types::StructLikeId> __jakt_var_461; {
-TRY((((*this).error(Jakt::DeprecatedString("Can't use non-struct type as an optional type in optional chained call"sv),span))));
-(found_optional = false);
-__jakt_var_461 =  types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),optional_struct_id) } ; goto __jakt_label_424;
+TRY((((((generic_inferences))).set(lhs_type_id_string,rhs_type_id_string))));
+}
 
 }
-__jakt_label_424:; __jakt_var_461.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& lhs_enum_id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& lhs_args = __jakt_match_value.args;
+{
+if (((rhs_type)->index() == 20 /* GenericEnumInstance */)){
+types::EnumId const rhs_enum_id = ((rhs_type)->get<types::Type::GenericEnumInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const rhs_args = ((rhs_type)->get<types::Type::GenericEnumInstance>()).args;
+if (((lhs_enum_id).equals(rhs_enum_id))){
+types::CheckedEnum const lhs_enum = ((*this).get_enum(lhs_enum_id));
+if ((((lhs_args).size()) == ((rhs_args).size()))){
+size_t idx = static_cast<size_t>(0ULL);
+while ((idx < ((lhs_args).size()))){
+if ((!(TRY((((*this).check_types_for_compat(((lhs_args)[idx]),((rhs_args)[idx]),generic_inferences,span))))))){
+return (false);
+}
+(++(idx));
+}
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("mismatched number of generic parameters for {}"sv),((lhs_enum).name)))),span))));
+return (false);
 }
-
-__jakt_var_460 = static_cast<JaktInternal::Optional<types::StructLikeId>>(struct_id.value_or_lazy_evaluated([&] { return  types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),optional_struct_id) } ; })); goto __jakt_label_423;
 
 }
-__jakt_label_423:; __jakt_var_460.release_value(); }));
 }
 else {
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Struct(args,id) } ));
+if ((!(((rhs_type_id).equals(lhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
+}
 }
-}()))
-; goto __jakt_label_422;
 
 }
-__jakt_label_422:; __jakt_var_459.release_value(); }));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Enum(args,id) } ));
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
-types::TraitId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Trait(JaktInternal::OptionalNone(),id) } ));
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Trait(args,id) } ));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::TypeVariable>();JaktInternal::DynamicArray<types::TypeId> const& trait_implementations = __jakt_match_value.trait_implementations;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = (((trait_implementations).size()));
-if (__jakt_enum_value == static_cast<size_t>(0ULL)) {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& lhs_params = __jakt_match_value.params;
+bool const& lhs_can_throw = __jakt_match_value.can_throw;
+types::TypeId const& lhs_return_type_id = __jakt_match_value.return_type_id;
+{
+if (((rhs_type)->index() == 29 /* Function */)){
+JaktInternal::DynamicArray<types::TypeId> const rhs_params = ((rhs_type)->get<types::Type::Function>()).params;
+bool const rhs_can_throw = ((rhs_type)->get<types::Type::Function>()).can_throw;
+types::TypeId const rhs_return_type_id = ((rhs_type)->get<types::Type::Function>()).return_type_id;
+if ((!((lhs_can_throw == rhs_can_throw)))){
+DeprecatedString const lhs_throw = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<bool>>{
+auto __jakt_enum_value = (lhs_can_throw);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Yes"sv));
 }
 else {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(((trait_implementations)[static_cast<i64>(0LL)])));
-switch(__jakt_match_variant.index()) {
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
-types::TraitId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Trait(JaktInternal::OptionalNone(),id) } ));
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Trait(args,id) } ));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-}/*switch end*/
-}()
-)));
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("No"sv));
 }
 }()))
-);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<types::StructLikeId> __jakt_var_462; {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("no methods available on value (type: {} {})"sv),((((*this).get_type(checked_expr_type_id)))->constructor_name()),TRY((((*this).type_name(checked_expr_type_id,false))))))),((checked_expr)->span())))));
-__jakt_var_462 = JaktInternal::OptionalNone(); goto __jakt_label_425;
+;
+DeprecatedString const rhs_throw = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<bool>>{
+auto __jakt_enum_value = (rhs_can_throw);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Yes"sv));
+}
+else {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("No"sv));
+}
+}()))
+;
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Function can throw mismatch: expected ‘{}’, but got ‘{}’"sv),lhs_throw,rhs_throw))),span))));
+}
+if ((!((((lhs_params).size()) == ((rhs_params).size()))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Function parameter count mismatch: expected ‘{}’, but got ‘{}’"sv),((lhs_params).size()),((rhs_params).size())))),span))));
+return (false);
+}
+if ((!(TRY((((*this).check_types_for_compat(lhs_return_type_id,rhs_return_type_id,generic_inferences,span))))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Function type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("The return types differ: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_return_type_id,false)))),TRY((((*this).type_name(rhs_return_type_id,false))))))),span))));
+return (false);
+}
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(0LL),static_cast<size_t>(((lhs_params).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if ((!(TRY((((*this).check_types_for_compat(((lhs_params)[i]),((rhs_params)[i]),generic_inferences,span))))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Function type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("The parameter types differ at argument {}: expected ‘{}’, but got ‘{}’"sv),(JaktInternal::checked_add<size_t>(i,static_cast<size_t>(1ULL))),TRY((((*this).type_name(((lhs_params)[i]),false)))),TRY((((*this).type_name(((rhs_params)[i]),false))))))),span))));
+return (false);
+}
+}
 
 }
-__jakt_label_425:; __jakt_var_462; }));
-};/*case end*/
-}/*switch end*/
-}()
-));
-if ((is_optional && (!(found_optional)))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Optional chain mismatch: expected optional chain, found {}"sv),TRY((((*this).type_name(checked_expr_type_id,false))))))),((checked_expr)->span())))));
 }
-NonnullRefPtr<typename types::CheckedExpression> const checked_call_expr = TRY((((*this).typecheck_call(call,scope_id,span,checked_expr,parent_id,safety_mode,type_hint,false))));
-types::TypeId const type_id = ((checked_call_expr)->type());
-__jakt_var_458 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *checked_call_expr;
-switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_463; {
-types::TypeId result_type = ((call).return_type);
-if (is_optional){
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-(result_type = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({result_type}))))))))))));
+
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
 }
-__jakt_var_463 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::MethodCall>(checked_expr,call,span,is_optional,result_type))); goto __jakt_label_426;
 
 }
-__jakt_label_426:; __jakt_var_463.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
 {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_call should return `CheckedExpression::Call()`"sv)))));
+types::StructId const lhs_struct_id = id;
+JaktInternal::DynamicArray<types::TypeId> const lhs_args = args;
+if ((((lhs_struct_id).equals(optional_struct_id)) || ((lhs_struct_id).equals(weakptr_struct_id)))){
+if ((((lhs_args).size()) > static_cast<size_t>(0ULL))){
+if (((((lhs_args)[static_cast<i64>(0LL)])).equals(rhs_type_id))){
+return (true);
 }
-};/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_421;
-
 }
-__jakt_label_421:; __jakt_var_458.release_value(); }));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& from = __jakt_match_value.from;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& to = __jakt_match_value.to;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_464; {
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_from = JaktInternal::OptionalNone();
-JaktInternal::Optional<types::TypeId> from_type = JaktInternal::OptionalNone();
-utility::Span from_span = span;
-if ((((from).has_value()) && ((!((((from.value()))->index() == 1 /* NumericConstant */))) && (!((((from.value()))->index() == 1 /* NumericConstant */)))))){
-(checked_from = TRY((((*this).typecheck_expression((from.value()),scope_id,safety_mode,JaktInternal::OptionalNone())))));
-(from_type = (((checked_from.value()))->type()));
-(from_span = (((checked_from.value()))->span()));
 }
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_to = JaktInternal::OptionalNone();
-types::TypeId to_type = types::unknown_type_id();
-utility::Span to_span = span;
-if (((to).has_value())){
-(checked_to = TRY((((*this).typecheck_expression((to.value()),scope_id,safety_mode,from_type)))));
-(to_type = (((checked_to.value()))->type()));
-(to_span = (((checked_to.value()))->span()));
+if (((rhs_type)->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((rhs_type)->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((rhs_type)->get<types::Type::GenericInstance>()).args;
+types::StructId const rhs_struct_id = id;
+if (((lhs_struct_id).equals(rhs_struct_id))){
+JaktInternal::DynamicArray<types::TypeId> const rhs_args = args;
+types::CheckedStruct const lhs_struct = ((*this).get_struct(lhs_struct_id));
+if ((((lhs_args).size()) == ((rhs_args).size()))){
+size_t idx = static_cast<size_t>(0ULL);
+while ((idx < ((args).size()))){
+if ((!(TRY((((*this).check_types_for_compat(((lhs_args)[idx]),((rhs_args)[idx]),generic_inferences,span))))))){
+return (false);
 }
-if ((((from).has_value()) && ((((from.value()))->index() == 1 /* NumericConstant */) || (((from.value()))->index() == 1 /* NumericConstant */)))){
-(checked_from = TRY((((*this).typecheck_expression((from.value()),scope_id,safety_mode,to_type)))));
-(from_type = (((checked_from.value()))->type()));
-(from_span = (((checked_from.value()))->span()));
+(++(idx));
 }
-JaktInternal::Optional<types::TypeId> values_type_id = JaktInternal::OptionalNone();
-if ((((from).has_value()) && ((to).has_value()))){
-(values_type_id = TRY((((*this).unify((from_type.value()),from_span,to_type,from_span)))));
-if ((!(((values_type_id).has_value())))){
-TRY((((*this).error(Jakt::DeprecatedString("Range values differ in types"sv),span))));
 }
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("mismatched number of generic parameters for {}"sv),((lhs_struct).name)))),span))));
+return (false);
 }
-else if (((from).has_value())){
-(values_type_id = from_type);
+
+}
+else if (((lhs_struct_id).equals(array_struct_id))){
+types::TypeId const array_value_type_id = ((args)[static_cast<i64>(0LL)]);
+if (((array_value_type_id).equals(types::unknown_type_id()))){
+return (true);
+}
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
+}
+
+}
+else {
+if ((!(((rhs_type_id).equals(lhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
 }
-else if (((to).has_value())){
-(values_type_id = to_type);
 }
-types::StructId const range_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Range"sv)))));
-NonnullRefPtr<typename types::Type> const range_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(range_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({((values_type_id).value_or(types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } )))})))))));
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(range_type))));
-__jakt_var_464 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Range>(checked_from,checked_to,span,type_id))); goto __jakt_label_427;
 
 }
-__jakt_label_427:; __jakt_var_464.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Reflect>();NonnullRefPtr<typename parser::ParsedType> const& type = __jakt_match_value.type;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_465; {
-types::EnumId const reflected_type_enum_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Type"sv)))));
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+{
+if (((lhs_type_id).equals(rhs_type_id))){
+return (true);
+}
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<bool>>{
+auto&& __jakt_match_variant = *rhs_type;
 switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(id);
-};/*case end*/
-default: {
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
 {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("unreachable"sv)))));
+if (((enum_id).equals(id))){
+types::CheckedEnum const lhs_enum = ((*this).get_enum(enum_id));
+if ((((args).size()) != ((((lhs_enum).generic_parameters)).size()))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("mismatched number of generic parameters for {}"sv),((lhs_enum).name)))),span))));
+return (false);
+}
+size_t idx = static_cast<size_t>(0ULL);
+while ((idx < ((args).size()))){
+if ((!(TRY((((*this).check_types_for_compat(((((((lhs_enum).generic_parameters))[idx])).type_id),((args)[idx]),generic_inferences,span))))))){
+return (false);
+}
+(++(idx));
+}
 }
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-types::TypeId const reflected_type = TRY((((*this).typecheck_typename(type,scope_id,JaktInternal::OptionalNone()))));
-__jakt_var_465 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Reflect>(reflected_type,span,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(reflected_type_enum_id)))))))))); goto __jakt_label_428;
+case 18: {
+{
+JaktInternal::Optional<DeprecatedString> const seen_type_id_string = ((((generic_inferences))).get(rhs_type_id_string));
+if (((seen_type_id_string).has_value())){
+if ((((seen_type_id_string).value()) != lhs_type_id_string)){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(TRY((types::TypeId::from_string(((seen_type_id_string).value())))),false))))))),span))));
+return (false);
+}
+}
+else {
+TRY((((((generic_inferences))).set(lhs_type_id_string,rhs_type_id_string))));
+}
 
 }
-__jakt_label_428:; __jakt_var_465.release_value(); }));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-parser::UnaryOperator const& op = __jakt_match_value.op;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_466; {
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 5: {
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,JaktInternal::OptionalNone())))));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span)))));
+{
+if ((!(((rhs_type_id).equals(lhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
+}
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-types::CheckedUnaryOperator const checked_op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedUnaryOperator, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::PreIncrement() } );
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::PostIncrement() } );
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::PreDecrement() } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::PostDecrement() } );
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } );
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Dereference() } );
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::RawAddress() } );
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Reference() } );
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::MutableReference() } );
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::LogicalNot() } );
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::BitwiseNot() } );
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::TypeCast>();
-parser::TypeCast const& cast = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::CheckedUnaryOperator> __jakt_var_467; {
-types::TypeId const type_id = TRY((((*this).typecheck_typename(((cast).parsed_type()),scope_id,JaktInternal::OptionalNone()))));
-types::CheckedTypeCast const checked_cast = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedTypeCast, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = cast;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(({ Optional<types::CheckedTypeCast> __jakt_var_468; {
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-NonnullRefPtr<typename types::Type> const optional_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({type_id})))))));
-types::TypeId const optional_type_id = TRY((((*this).find_or_add_type_id(optional_type))));
-__jakt_var_468 =  types::CheckedTypeCast { typename types::CheckedTypeCast::Fallible(optional_type_id) } ; goto __jakt_label_431;
-
-}
-__jakt_label_431:; __jakt_var_468.release_value(); }));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue( types::CheckedTypeCast { typename types::CheckedTypeCast::Infallible(type_id) } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-__jakt_var_467 =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::TypeCast(checked_cast) } ; goto __jakt_label_430;
-
-}
-__jakt_label_430:; __jakt_var_467.release_value(); }));
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Sizeof>();
-NonnullRefPtr<typename parser::ParsedType> const& unchecked_type = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::CheckedUnaryOperator> __jakt_var_469; {
-types::TypeId const type_id = TRY((((*this).typecheck_typename(unchecked_type,scope_id,JaktInternal::OptionalNone()))));
-__jakt_var_469 =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Sizeof(type_id) } ; goto __jakt_label_432;
-
-}
-__jakt_label_432:; __jakt_var_469.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Is>();
-NonnullRefPtr<typename parser::ParsedType> const& unchecked_type = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::CheckedUnaryOperator> __jakt_var_470; {
-bool const old_ignore_errors = ((*this).ignore_errors);
-(((*this).ignore_errors) = true);
-types::TypeId const type_id = TRY((((*this).typecheck_typename(unchecked_type,scope_id,JaktInternal::OptionalNone()))));
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
-types::CheckedUnaryOperator operator_is =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Is(type_id) } ;
-if (((unchecked_type)->index() == 0 /* Name */)){
-DeprecatedString const name = ((unchecked_type)->get<parser::ParsedType::Name>()).name;
-types::TypeId const expr_type_id = ((checked_expr)->type());
-if (((((*this).get_type(expr_type_id)))->index() == 24 /* Enum */)){
-types::EnumId const enum_id = ((((*this).get_type(expr_type_id)))->get<types::Type::Enum>()).value;
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-bool exists = false;
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& lhs_struct_id = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((lhs_type_id).equals(rhs_type_id))){
+return (true);
 }
-types::CheckedEnumVariant variant = (_magic_value.value());
-{
-(exists = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = variant;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<bool>>{
+auto&& __jakt_match_variant = *rhs_type;
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& var_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue((var_name == name));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& var_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue((var_name == name));
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& var_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue((var_name == name));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& var_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue((var_name == name));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-if (exists){
-(operator_is =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::IsEnumVariant(variant,(TRY((DynamicArray<types::CheckedEnumVariantBinding>::create_with({})))),expr_type_id) } );
-break;
-}
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+{
+if ((!(((lhs_struct_id).equals(id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
 }
-
+types::CheckedStruct const lhs_struct = ((*this).get_struct(lhs_struct_id));
+if ((((args).size()) != ((((lhs_struct).generic_parameters)).size()))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("mismatched number of generic parameters for {}"sv),((lhs_struct).name)))),span))));
+return (false);
 }
+size_t idx = static_cast<size_t>(0ULL);
+while ((idx < ((args).size()))){
+if ((!(TRY((((*this).check_types_for_compat(((((((lhs_struct).generic_parameters))[idx])).type_id),((args)[idx]),generic_inferences,span))))))){
+return (false);
 }
-
-if (((!(exists)) && ((type_id).equals(types::unknown_type_id())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist on {}"sv),name,TRY((((*this).type_name(expr_type_id,false))))))),span))));
+(++(idx));
 }
 }
-else if (((type_id).equals(types::unknown_type_id()))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),name))),span))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 18: {
+{
+JaktInternal::Optional<DeprecatedString> const seen_type_id_string = ((((generic_inferences))).get(rhs_type_id_string));
+if (((seen_type_id_string).has_value())){
+if ((((seen_type_id_string).value()) != lhs_type_id_string)){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(TRY((types::TypeId::from_string(((seen_type_id_string).value())))),false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
 }
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("The right-hand side of an `is` operator must be a type name or enum variant"sv),span))));
+TRY((((((generic_inferences))).set(lhs_type_id_string,rhs_type_id_string))));
 }
 
-__jakt_var_470 = operator_is; goto __jakt_label_433;
-
 }
-__jakt_label_433:; __jakt_var_470.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::UnaryOperator::IsEnumVariant>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& bindings = __jakt_match_value.bindings;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_is_enum_variant(checked_expr,inner,bindings,scope_id)))));
+default: {
+{
+NonnullRefPtr<typename types::Type> const rhs_type = ((*this).get_type(rhs_type_id));
+if (((*this).is_subclass_of(lhs_type_id,rhs_type_id))){
+return (true);
+}
+if ((!(((rhs_type_id).equals(lhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
+}
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 ));
-__jakt_var_466 = TRY((((*this).typecheck_unary_operation(checked_expr,checked_op,span,scope_id,safety_mode)))); goto __jakt_label_429;
-
 }
-__jakt_label_429:; __jakt_var_466.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs = __jakt_match_value.lhs;
-parser::BinaryOperator const& op = __jakt_match_value.op;
-NonnullRefPtr<typename parser::ParsedExpression> const& rhs = __jakt_match_value.rhs;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_471; {
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> original_checked_lhs = JaktInternal::OptionalNone();
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> original_checked_rhs = JaktInternal::OptionalNone();
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_lhs = JaktInternal::OptionalNone();
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_rhs = JaktInternal::OptionalNone();
-if ((((lhs)->index() == 1 /* NumericConstant */) || ((lhs)->index() == 1 /* NumericConstant */))){
-(original_checked_rhs = TRY((((*this).typecheck_expression(rhs,scope_id,safety_mode,JaktInternal::OptionalNone())))));
-(checked_rhs = TRY((((*this).dereference_if_needed((original_checked_rhs.value()),span)))));
-types::TypeId const hint = (((checked_rhs.value()))->type());
-(original_checked_lhs = TRY((((*this).typecheck_expression(lhs,scope_id,safety_mode,hint)))));
-(checked_lhs = TRY((((*this).dereference_if_needed((original_checked_lhs.value()),span)))));
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
+types::TypeId const& lhs_rawptr_type_id = __jakt_match_value.value;
+{
+if (((lhs_rawptr_type_id).equals(rhs_type_id))){
+return (true);
 }
-else {
-(original_checked_lhs = TRY((((*this).typecheck_expression(lhs,scope_id,safety_mode,JaktInternal::OptionalNone())))));
-(checked_lhs = TRY((((*this).dereference_if_needed((original_checked_lhs.value()),span)))));
-types::TypeId const hint = (((checked_lhs.value()))->type());
-(original_checked_rhs = TRY((((*this).typecheck_expression(rhs,scope_id,safety_mode,hint)))));
-(checked_rhs = TRY((((*this).dereference_if_needed((original_checked_rhs.value()),span)))));
+if (((rhs_type)->index() == 25 /* RawPtr */)){
+types::TypeId const rhs_rawptr_type_id = ((rhs_type)->get<types::Type::RawPtr>()).value;
+if ((!(TRY((((*this).check_types_for_compat(lhs_rawptr_type_id,rhs_rawptr_type_id,generic_inferences,span))))))){
+return (false);
 }
-
-if ((TRY((((*this).type_contains_reference((((original_checked_lhs.value()))->type()))))) && ((rhs)->index() == 11 /* UnaryOp */))){
-parser::UnaryOperator const op = ((rhs)->get<parser::ParsedExpression::UnaryOp>()).op;
-if ((((op).index() == 7 /* Reference */) || ((op).index() == 8 /* MutableReference */))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Attempt to rebind a reference will result in write-through"sv),span,Jakt::DeprecatedString("This reference will be immediately dereferenced and then assigned"sv),((rhs)->span())))));
+}
+else {
+if ((!(((rhs_type_id).equals(lhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
 }
 }
-types::TypeId const output_type = TRY((((*this).typecheck_binary_operation((checked_lhs.value()),op,(checked_rhs.value()),scope_id,span))));
-__jakt_var_471 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::BinaryOp>((checked_lhs.value()),op,(checked_rhs.value()),span,output_type))); goto __jakt_label_434;
 
 }
-__jakt_label_434:; __jakt_var_471.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedExpression::OptionalNone>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_472; {
-JaktInternal::Optional<types::TypeId> type_hint_unwrapped = type_hint;
-if ((((type_hint).has_value()) && ((((*this).get_type((type_hint.value()))))->index() == 19 /* GenericInstance */))){
-types::StructId const id = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).args;
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-if (((id).equals(optional_struct_id))){
-(type_hint_unwrapped = ((args)[static_cast<i64>(0LL)]));
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
+types::TypeId const& lhs_inner_type_id = __jakt_match_value.value;
+{
+if (((rhs_type)->index() == 27 /* Reference */)){
+types::TypeId const rhs_inner_type_id = ((rhs_type)->get<types::Type::Reference>()).value;
+if ((!(TRY((((*this).check_types_for_compat(lhs_inner_type_id,rhs_inner_type_id,generic_inferences,span))))))){
+return (false);
 }
 }
-__jakt_var_472 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::OptionalNone>(span,type_hint_unwrapped.value_or_lazy_evaluated([&] { return types::unknown_type_id(); })))); goto __jakt_label_435;
-
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
 }
-__jakt_label_435:; __jakt_var_472.release_value(); }));
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::OptionalSome>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_473; {
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-types::TypeId const type_id = ((checked_expr)->type());
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-NonnullRefPtr<typename types::Type> const optional_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({type_id})))))));
-types::TypeId const optional_type_id = TRY((((*this).find_or_add_type_id(optional_type))));
-__jakt_var_473 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::OptionalSome>(checked_expr,span,optional_type_id))); goto __jakt_label_436;
 
 }
-__jakt_label_436:; __jakt_var_473.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
+types::TypeId const& lhs_inner_type_id = __jakt_match_value.value;
 {
-JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const var = TRY((((*this).find_var_in_scope(scope_id,name))));
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto __jakt_enum_value = (((var).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Var>((var.value()),span))));
+if (((rhs_type)->index() == 28 /* MutableReference */)){
+types::TypeId const rhs_inner_type_id = ((rhs_type)->get<types::Type::MutableReference>()).value;
+if ((!(TRY((((*this).check_types_for_compat(lhs_inner_type_id,rhs_inner_type_id,generic_inferences,span))))))){
+return (false);
+}
 }
 else {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_474; {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Variable '{}' not found"sv),name))),span))));
-__jakt_var_474 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Var>(TRY((types::CheckedVariable::__jakt_create(name,((type_hint).value_or(types::unknown_type_id())),false,span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone()))),span))); goto __jakt_label_437;
-
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
 }
-__jakt_label_437:; __jakt_var_474.release_value(); }));
+
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+if ((((((generic_inferences))).map_name(rhs_type_id_string)) != ((((generic_inferences))).map_name(lhs_type_id_string)))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),span))));
+return (false);
 }
-}()))
-);
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ForcedUnwrap>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_475; {
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-NonnullRefPtr<typename types::Type> const type = ((*this).get_type(((checked_expr)->type())));
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-types::StructId const weakptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-types::TypeId const type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *type;
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_476; {
-types::TypeId inner_type_id = types::unknown_type_id();
-if ((((id).equals(optional_struct_id)) || ((id).equals(weakptr_struct_id)))){
-(inner_type_id = ((args)[static_cast<i64>(0LL)]));
+}/*switch end*/
+}()
+));
+return (true);
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Forced unwrap only works on Optional"sv),span))));
 }
 
-__jakt_var_476 = inner_type_id; goto __jakt_label_439;
-
-}
-__jakt_label_439:; __jakt_var_476.release_value(); }));
+ErrorOr<void> typechecker::Typechecker::typecheck_enum_predecl(parser::ParsedRecord const parsed_record,types::EnumId const enum_id,types::ScopeId const scope_id) {
+{
+types::TypeId const enum_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id)))))));
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = enum_type_id);
+ScopeGuard __jakt_var_445([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+types::ScopeId const enum_scope_id = TRY((((*this).create_scope(scope_id,false,TRY((__jakt_format(Jakt::DeprecatedString("enum({})"sv),((parsed_record).name)))),false))));
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(enum_scope_id))));
+(((scope)->namespace_name) = ((parsed_record).name));
+TRY((((*this).add_enum_to_scope(scope_id,((parsed_record).name),enum_id,((parsed_record).name_span)))));
+types::TypeId const underlying_type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((parsed_record).record_type);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::ValueEnum>();NonnullRefPtr<typename parser::ParsedType> const& underlying_type = __jakt_match_value.underlying_type;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_typename(underlying_type,scope_id,JaktInternal::OptionalNone())))));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_477; {
-TRY((((*this).error(Jakt::DeprecatedString("Forced unwrap only works on Optional"sv),span))));
-__jakt_var_477 = types::unknown_type_id(); goto __jakt_label_440;
-
-}
-__jakt_label_440:; __jakt_var_477.release_value(); }));
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } ));
 };/*case end*/
 }/*switch end*/
 }()
 ));
-__jakt_var_475 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::ForcedUnwrap>(checked_expr,span,type_id))); goto __jakt_label_438;
-
-}
-__jakt_label_438:; __jakt_var_475.release_value(); }));
+bool const is_boxed = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((parsed_record).record_type);
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::SumEnum>();bool const& is_boxed = __jakt_match_value.is_boxed;
+return JaktInternal::ExplicitValue(is_boxed);
 };/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& values = __jakt_match_value.values;
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& fill_size = __jakt_match_value.fill_size;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_array(scope_id,values,fill_size,span,safety_mode,type_hint)))));
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& values = __jakt_match_value.values;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_478; {
-types::TypeId const VOID_TYPE_ID = types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } );
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> checked_values = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedExpression>>::create_with({}))));
-JaktInternal::DynamicArray<types::TypeId> checked_types = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+}/*switch end*/
+}()
+));
+JaktInternal::DynamicArray<types::CheckedField> checked_fields = (TRY((DynamicArray<types::CheckedField>::create_with({}))));
+JaktInternal::Set<DeprecatedString> seen_fields = (TRY((Set<DeprecatedString>::create_with_values({}))));
+if (((((parsed_record).record_type)).index() == 3 /* SumEnum */)){
+JaktInternal::DynamicArray<parser::ParsedField> const fields = ((((parsed_record).record_type)).get<parser::RecordType::SumEnum>()).fields;
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedExpression>> _magic = ((values).iterator());
+JaktInternal::ArrayIterator<parser::ParsedField> _magic = ((fields).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedExpression> value = (_magic_value.value());
+parser::ParsedField field = (_magic_value.value());
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_value = TRY((((*this).typecheck_expression(value,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-types::TypeId const type_id = ((checked_value)->type());
-if (((type_id).equals(VOID_TYPE_ID))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot create a tuple that contains a value of type void"sv),((value)->span())))));
+parser::ParsedVarDecl const var_decl = ((field).var_decl);
+if (((seen_fields).contains(((var_decl).name)))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Field '{}' is defined more than once"sv),((var_decl).name)))),((var_decl).span)))));
+continue;
 }
-TRY((((checked_types).push(type_id))));
-TRY((((checked_values).push(checked_value))));
+TRY((((seen_fields).add(((var_decl).name)))));
+types::TypeId const type_id = TRY((((*this).typecheck_typename(((var_decl).parsed_type),enum_scope_id,((var_decl).name)))));
+NonnullRefPtr<types::CheckedVariable> const checked_var = TRY((types::CheckedVariable::__jakt_create(((var_decl).name),type_id,((var_decl).is_mutable),((var_decl).span),((((var_decl).parsed_type))->span()),TRY((((*this).typecheck_visibility(((field).visibility),enum_scope_id)))),JaktInternal::OptionalNone())));
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value = JaktInternal::OptionalNone();
+if (((((field).default_value)).has_value())){
+(default_value = TRY((((*this).typecheck_expression((((field).default_value).value()),enum_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,type_id)))));
+}
+if ((((*this).dump_type_hints) && ((((var_decl).parsed_type))->index() == 13 /* Empty */))){
+TRY((((*this).dump_type_hint(type_id,((var_decl).span)))));
+}
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::VarId const variable_id = TRY((((module)->add_variable(checked_var))));
+TRY((((checked_fields).push(types::CheckedField(variable_id,default_value,((field).default_value))))));
 }
 
 }
 }
 
-if ((((type_hint).has_value()) && ((((*this).get_type((type_hint.value()))))->index() == 19 /* GenericInstance */))){
-types::StructId const id = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).args;
-if ((((checked_types).size()) == ((args).size()))){
+}
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+(((((module)->enums))[((enum_id).id)]) = types::CheckedEnum(((parsed_record).name),((parsed_record).name_span),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),(TRY((DynamicArray<types::CheckedEnumVariant>::create_with({})))),checked_fields,enum_scope_id,((parsed_record).definition_linkage),(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))),((parsed_record).record_type),underlying_type_id,enum_type_id,is_boxed));
+JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters = ((((((module)->enums))[((enum_id).id)])).generic_parameters);
+TRY((((generic_parameters).ensure_capacity(((((parsed_record).generic_parameters)).size())))));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((args).size()))});
+JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((parsed_record).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+parser::ParsedGenericParameter gen_parameter = (_magic_value.value());
 {
-types::TypeId value_type = ((checked_types)[i]);
-JaktInternal::Optional<types::TypeId> const unified = TRY((((*this).unify(((args)[i]),span,value_type,span))));
-if (((unified).has_value())){
-bool type_optional = false;
-if (((((*this).get_type((unified.value()))))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type((unified.value()))))->get<types::Type::GenericInstance>()).id;
-if (((id).equals(optional_struct_id))){
-(type_optional = true);
+types::TypeId const parameter_type_id = types::TypeId(((*this).current_module_id),((((((*this).current_module()))->types)).size()));
+types::CheckedGenericParameter checked_param = TRY((types::CheckedGenericParameter::make(parameter_type_id,((gen_parameter).span))));
+JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((gen_parameter).name),trait_implementations)))))));
+if (((((gen_parameter).requires_list)).has_value())){
+TRY((((*this).fill_trait_requirements((((gen_parameter).requires_list).value()),((((checked_param).constraints))),((trait_implementations)),scope_id))));
 }
+TRY((((generic_parameters).push(checked_param))));
+TRY((((*this).add_type_to_scope(enum_scope_id,((gen_parameter).name),parameter_type_id,((gen_parameter).span)))));
 }
-bool value_optional = false;
-if (((((*this).get_type(value_type)))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((((*this).get_type(value_type)))->get<types::Type::GenericInstance>()).id;
-if (((id).equals(optional_struct_id))){
-(value_optional = true);
+
 }
 }
-(((checked_types)[i]) = (unified.value()));
-if ((type_optional && ((!(value_optional)) && (!(((((checked_values)[i]))->index() == 26 /* OptionalSome */)))))){
-if ((((((checked_values)[i]))->index() == 25 /* OptionalNone */) && ((((*this).get_type((unified.value()))))->index() == 19 /* GenericInstance */))){
-types::StructId const id = ((((*this).get_type((unified.value()))))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type((unified.value()))))->get<types::Type::GenericInstance>()).args;
-(value_type = ((args)[static_cast<i64>(0LL)]));
+
+if (((((parsed_record).implements_list)).has_value())){
+TRY((((*this).fill_trait_implementation_list((((parsed_record).implements_list).value()),((((((((module)->enums))[((enum_id).id)])).trait_implementations))),enum_scope_id,JaktInternal::OptionalNone()))));
 }
-NonnullRefPtr<typename types::Type> const optional_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({value_type})))))));
-types::TypeId const optional_type_id = TRY((((*this).find_or_add_type_id(optional_type))));
-(((checked_values)[i]) = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::OptionalSome>(((checked_values)[i]),span,optional_type_id))));
+bool const is_extern = ((((parsed_record).definition_linkage)).index() == 1 /* External */);
+{
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((parsed_record).methods)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::ParsedMethod method = (_magic_value.value());
+{
+parser::ParsedFunction const func = ((method).parsed_function);
+types::ScopeId const method_scope_id = TRY((((*this).create_scope(enum_scope_id,((func).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("method({}::{})"sv),((parsed_record).name),((func).name)))),true))));
+types::ScopeId const block_scope_id = TRY((((*this).create_scope(method_scope_id,((func).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("method-block({}::{})"sv),((parsed_record).name),((func).name)))),true))));
+bool const is_generic = ((!(((((parsed_record).generic_parameters)).is_empty()))) || (!(((((func).generic_parameters)).is_empty()))));
+NonnullRefPtr<types::CheckedFunction> checked_function = TRY((types::CheckedFunction::__jakt_create(((func).name),((func).name_span),TRY((((*this).typecheck_visibility(((method).visibility),enum_scope_id)))),types::unknown_type_id(),JaktInternal::OptionalNone(),(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),TRY((types::FunctionGenerics::__jakt_create(method_scope_id,(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false),((func).can_throw),((func).type),((func).linkage),method_scope_id,JaktInternal::OptionalNone(),((!(is_generic)) || is_extern),func,((func).is_comptime),false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
+types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
+JaktInternal::DynamicArray<types::FunctionGenericParameter> generic_parameters = (TRY((DynamicArray<types::FunctionGenericParameter>::create_with({}))));
+{
+JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((func).generic_parameters)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::ParsedGenericParameter generic_parameter = (_magic_value.value());
+{
+types::TypeId const type_var_type_id = types::TypeId(((*this).current_module_id),((((((*this).current_module()))->types)).size()));
+types::FunctionGenericParameter parameter = TRY((types::FunctionGenericParameter::parameter(type_var_type_id,((generic_parameter).span))));
+JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((generic_parameter).name),trait_implementations)))))));
+if (((((generic_parameter).requires_list)).has_value())){
+TRY((((*this).fill_trait_requirements((((generic_parameter).requires_list).value()),((((((parameter).checked_parameter)).constraints))),((trait_implementations)),scope_id))));
 }
+TRY((((generic_parameters).push(parameter))));
+if ((!(((func).must_instantiate)))){
+TRY((((*this).add_type_to_scope(method_scope_id,((generic_parameter).name),type_var_type_id,((generic_parameter).span)))));
 }
 }
 
 }
 }
 
+(((((checked_function)->generics))->params) = generic_parameters);
+{
+JaktInternal::ArrayIterator<parser::ParsedParameter> _magic = ((((func).params)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+parser::ParsedParameter param = (_magic_value.value());
+{
+if ((((((param).variable)).name) == Jakt::DeprecatedString("this"sv))){
+NonnullRefPtr<types::CheckedVariable> const checked_variable = TRY((types::CheckedVariable::__jakt_create(((((param).variable)).name),enum_type_id,((((param).variable)).is_mutable),((((param).variable)).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
+TRY((((checked_function)->add_param(types::CheckedParameter(((param).requires_label),checked_variable,JaktInternal::OptionalNone())))));
 }
+else {
+types::TypeId const param_type = TRY((((*this).typecheck_typename(((((param).variable)).parsed_type),method_scope_id,((((param).variable)).name)))));
+NonnullRefPtr<types::CheckedVariable> const checked_variable = TRY((types::CheckedVariable::__jakt_create(((((param).variable)).name),param_type,((((param).variable)).is_mutable),((((param).variable)).span),((((((param).variable)).parsed_type))->span()), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value = JaktInternal::OptionalNone();
+if (((((param).default_argument)).has_value())){
+types::TypeId const param_type = TRY((((*this).typecheck_typename(((((param).variable)).parsed_type),method_scope_id,((((param).variable)).name)))));
+(default_value = TRY((((*this).typecheck_expression((((param).default_argument).value()),scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,param_type)))));
 }
-types::StructId const tuple_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(tuple_struct_id,checked_types)))))));
-if (((type_hint).has_value())){
-TRY((((*this).check_types_for_compat((type_hint.value()),type_id,((((*this).generic_inferences))),span))));
+TRY((((checked_function)->add_param(types::CheckedParameter(((param).requires_label),checked_variable,default_value)))));
 }
-__jakt_var_478 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::JaktTuple>(checked_values,span,type_id))); goto __jakt_label_441;
 
 }
-__jakt_label_441:; __jakt_var_478.release_value(); }));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedExpression>();NonnullRefPtr<typename parser::ParsedExpression> const& base = __jakt_match_value.base;
-NonnullRefPtr<typename parser::ParsedExpression> const& index = __jakt_match_value.index;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_479; {
-NonnullRefPtr<typename types::CheckedExpression> const checked_base = TRY((((*this).typecheck_expression_and_dereference_if_needed(base,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-NonnullRefPtr<typename types::CheckedExpression> const checked_index = TRY((((*this).typecheck_expression_and_dereference_if_needed(index,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-__jakt_var_479 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(((checked_base)->type())));
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_480; {
-types::StructId const array_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-types::StructId const array_slice_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("ArraySlice"sv)))));
-types::StructId const dictionary_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
-NonnullRefPtr<typename types::CheckedExpression> result = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span)));
-if ((((id).equals(array_struct_id)) || ((id).equals(array_slice_struct_id)))){
-if ((((*this).is_integer(((checked_index)->type()))) || ((checked_index)->index() == 9 /* Range */))){
-types::TypeId const type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *checked_index;
-switch(__jakt_match_variant.index()) {
-case 9: {
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_481; {
-types::StructId const array_slice_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("ArraySlice"sv)))));
-__jakt_var_481 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_slice_struct_id,args))))))); goto __jakt_label_444;
 
 }
-__jakt_label_444:; __jakt_var_481.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(((args)[static_cast<i64>(0LL)]));
-};/*case end*/
-}/*switch end*/
-}()
-));
-(result = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedExpression>(checked_base,checked_index,span,type_id))));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Index must be an integer or a range"sv),span))));
+
+TRY((((*this).add_function_to_scope(enum_scope_id,((func).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((parsed_record).name_span)))));
+types::TypeId const function_return_type_id = TRY((((*this).typecheck_typename(((func).return_type),method_scope_id,JaktInternal::OptionalNone()))));
+(((checked_function)->return_type_id) = function_return_type_id);
 }
 
 }
-else if (((id).equals(dictionary_struct_id))){
-(result = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedDictionary>(checked_base,checked_index,span,((args)[static_cast<i64>(1LL)])))));
 }
-__jakt_var_480 = result; goto __jakt_label_443;
 
 }
-__jakt_label_443:; __jakt_var_480.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_482; {
-TRY((((*this).error(Jakt::DeprecatedString("Index used on value that cannot be indexed"sv),span))));
-__jakt_var_482 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))); goto __jakt_label_445;
-
+return {};
 }
-__jakt_label_445:; __jakt_var_482.release_value(); }));
-};/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_442;
 
-}
-__jakt_label_442:; __jakt_var_479.release_value(); }));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedTuple>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-size_t const& index = __jakt_match_value.index;
-bool const& is_optional = __jakt_match_value.is_optional;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_tuple(expr,index,scope_id,is_optional,safety_mode,span)))));
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedExpression::Garbage>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NamespacedVar>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<DeprecatedString> const& namespace_ = __jakt_match_value.namespace_;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_namespaced_var_or_simple_enum_constructor_call(name,namespace_,scope_id,safety_mode,type_hint,span)))));
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Match>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-JaktInternal::DynamicArray<parser::ParsedMatchCase> const& cases = __jakt_match_value.cases;
-utility::Span const& marker_span = __jakt_match_value.marker_span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_match(expr,cases,marker_span,scope_id,safety_mode,type_hint)))));
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::EnumVariantArg>();NonnullRefPtr<typename parser::ParsedExpression> const& inner_expr = __jakt_match_value.expr;
-parser::EnumVariantPatternArgument const& arg = __jakt_match_value.arg;
-NonnullRefPtr<typename parser::ParsedType> const& enum_variant = __jakt_match_value.enum_variant;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_483; {
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(inner_expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-types::CheckedEnumVariantBinding checked_binding = types::CheckedEnumVariantBinding(Jakt::DeprecatedString(""sv),Jakt::DeprecatedString(""sv),types::unknown_type_id(),span);
-JaktInternal::Optional<types::CheckedEnumVariant> checked_enum_variant = JaktInternal::OptionalNone();
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *enum_variant;
+ErrorOr<void> typechecker::Typechecker::check_member_access(types::ScopeId const accessor,types::ScopeId const accessee,NonnullRefPtr<types::CheckedVariable> const member,utility::Span const span) {
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((member)->visibility);
 switch(__jakt_match_variant.index()) {
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& variant_name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(((checked_expr)->type())));
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
 {
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-JaktInternal::Optional<types::CheckedEnumVariant> const variant = TRY((((*this).get_enum_variant(enum_,variant_name))));
-if (((variant).has_value())){
-(checked_enum_variant = variant);
-JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>> const checked_bindings = TRY((((*this).typecheck_enum_variant_bindings((variant.value()),(TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({arg})))),span))));
-if (((checked_bindings).has_value())){
-JaktInternal::DynamicArray<types::CheckedEnumVariantBinding> const bindings = (checked_bindings.value());
-(checked_binding = ((bindings)[static_cast<i64>(0LL)]));
-}
+if ((!(TRY((((*this).scope_can_access(accessor,accessee))))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't access field ‘{}’, because it is marked private"sv),((member)->name)))),span))));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist"sv),variant_name))),span))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedVisibility::Restricted>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> const& scopes = __jakt_match_value.scopes;
+{
+TRY((((*this).check_restricted_access(accessor,Jakt::DeprecatedString("field"sv),accessee,((member)->name),scopes,span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),variant_name))),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-))), JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& variant_name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(((checked_expr)->type())));
-switch(__jakt_match_variant.index()) {
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-{
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-JaktInternal::Optional<types::CheckedEnumVariant> const variant = TRY((((*this).get_enum_variant(enum_,variant_name))));
-if (((variant).has_value())){
-(checked_enum_variant = variant);
-JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>> const checked_bindings = TRY((((*this).typecheck_enum_variant_bindings((variant.value()),(TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({arg})))),span))));
-if (((checked_bindings).has_value())){
-JaktInternal::DynamicArray<types::CheckedEnumVariantBinding> const bindings = (checked_bindings.value());
-(checked_binding = ((bindings)[static_cast<i64>(0LL)]));
-}
+));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist"sv),variant_name))),span))));
+return {};
 }
 
+bool typechecker::Typechecker::is_integer(types::TypeId const type_id) const {
+{
+return (((((*this).program))->is_integer(type_id)));
 }
-return JaktInternal::ExplicitValue<void>();
+}
+
+ErrorOr<bool> typechecker::Typechecker::signatures_match(types::TypeId const self_type_id,NonnullRefPtr<types::CheckedFunction> const first,NonnullRefPtr<types::CheckedFunction> const second) {
+{
+Function<ErrorOr<bool>(typechecker::Typechecker&, types::TypeId, types::TypeId)> const types_match = [self_type_id](typechecker::Typechecker& typechecker, types::TypeId a, types::TypeId b) -> ErrorOr<bool> {
+{
+types::TypeId const mapped_a = TRY((((((((typechecker))).generic_inferences)).map(a))));
+types::TypeId const mapped_b = TRY((((((((typechecker))).generic_inferences)).map(b))));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<bool>>{
+auto&& __jakt_match_variant = *((((typechecker))).get_type(mapped_a));
+switch(__jakt_match_variant.index()) {
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
+types::TraitId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((((typechecker))).implements_trait(mapped_b,id,JaktInternal::OptionalNone())))));
 };/*case end*/
-default: {
+case 30: {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_446; {
+bool const old_ignore_errors = ((((typechecker))).ignore_errors);
+(((((typechecker))).ignore_errors) = true);
+ScopeGuard __jakt_var_447([&] {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),variant_name))),span))));
+(((((typechecker))).ignore_errors) = old_ignore_errors);
+(((((typechecker))).had_an_error) = false);
 }
-return JaktInternal::ExplicitValue<void>();
+
+});
+__jakt_var_446 = TRY((((((typechecker))).check_types_for_compat(self_type_id,mapped_b,((((((typechecker))).generic_inferences))),utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)))))); goto __jakt_label_411;
+
+}
+__jakt_label_411:; __jakt_var_446.release_value(); }));
 };/*case end*/
-}/*switch end*/
-}()
-))), JaktInternal::ExplicitValue<void>();
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(TRY((((((typechecker))).implements_trait(mapped_b,id,args)))));
 };/*case end*/
 default: {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_448; {
+bool const old_ignore_errors = ((((typechecker))).ignore_errors);
+(((((typechecker))).ignore_errors) = true);
+ScopeGuard __jakt_var_449([&] {
 {
+(((((typechecker))).ignore_errors) = old_ignore_errors);
+(((((typechecker))).had_an_error) = false);
 }
-return JaktInternal::ExplicitValue<void>();
+
+});
+__jakt_var_448 = TRY((((((typechecker))).check_types_for_compat(mapped_a,mapped_b,((((((typechecker))).generic_inferences))),utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)))))); goto __jakt_label_412;
+
+}
+__jakt_label_412:; __jakt_var_448.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
-));
-NonnullRefPtr<typename types::CheckedExpression> output = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span)));
-if (((checked_enum_variant).has_value())){
-(output = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::EnumVariantArg>(checked_expr,checked_binding,(checked_enum_variant.value()),span))));
+)));
+}
+}
+;
+if (TRY((types_match(((*this)),((first)->return_type_id),((second)->return_type_id))))){
+if ((((first)->can_throw) == ((second)->can_throw))){
+if ((((((first)->params)).size()) == ((((second)->params)).size()))){
+size_t arg_start = static_cast<size_t>(0ULL);
+if (((first)->is_static())){
+if (((second)->is_static())){
+}
+else {
+return (false);
 }
-__jakt_var_483 = output; goto __jakt_label_446;
 
 }
-__jakt_label_446:; __jakt_var_483.release_value(); }));
-};/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const& values = __jakt_match_value.values;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_dictionary(values,span,scope_id,safety_mode,type_hint)))));
-};/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Set>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& values = __jakt_match_value.values;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_set(values,span,scope_id,safety_mode,type_hint)))));
-};/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Function>();JaktInternal::DynamicArray<parser::ParsedCapture> const& captures = __jakt_match_value.captures;
-JaktInternal::DynamicArray<parser::ParsedParameter> const& params = __jakt_match_value.params;
-bool const& can_throw = __jakt_match_value.can_throw;
-bool const& is_fat_arrow = __jakt_match_value.is_fat_arrow;
-NonnullRefPtr<typename parser::ParsedType> const& return_type = __jakt_match_value.return_type;
-parser::ParsedBlock const& block = __jakt_match_value.block;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_lambda(captures,params,can_throw,is_fat_arrow,return_type,block,span,scope_id,safety_mode)))));
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Try>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-JaktInternal::Optional<parser::ParsedBlock> const& catch_block = __jakt_match_value.catch_block;
-JaktInternal::Optional<DeprecatedString> const& catch_name = __jakt_match_value.catch_name;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_try(expr,catch_block,catch_name,scope_id,safety_mode,span,type_hint)))));
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::TryBlock>();NonnullRefPtr<typename parser::ParsedStatement> const& stmt = __jakt_match_value.stmt;
-parser::ParsedBlock const& catch_block = __jakt_match_value.catch_block;
-DeprecatedString const& error_name = __jakt_match_value.error_name;
-utility::Span const& error_span = __jakt_match_value.error_span;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_try_block(stmt,error_name,error_span,catch_block,scope_id,safety_mode,span)))));
-};/*case end*/
-case 13: {
-{
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("idk how to handle this thing"sv)))));
+else {
+if ((!(((second)->is_static())))){
+if ((((first)->is_mutating()) == ((second)->is_mutating()))){
+(arg_start = static_cast<size_t>(1ULL));
 }
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+else {
+return (false);
 }
+
+}
+else {
+return (false);
+}
+
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_struct_constructor(parser::ParsedRecord const parsed_record,types::StructId const struct_id,types::ScopeId const scope_id) {
-{
-types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
-(((*this).current_struct_type_id) = struct_type_id);
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = struct_type_id);
-ScopeGuard __jakt_var_484([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
-types::CheckedStruct const struct_ = ((*this).get_struct(struct_id));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const constructor_ids = TRY((((*this).find_functions_with_name_in_scope(((struct_).scope_id),((parsed_record).name)))));
-if (((constructor_ids).has_value())){
-if ((((((parsed_record).record_type)).index() == 1 /* Class */) && ((((parsed_record).definition_linkage)).index() == 1 /* External */))){
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = (((constructor_ids.value())).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(arg_start),static_cast<size_t>(((((first)->params)).size()))});
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId constructor_id = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedFunction> func = ((*this).get_function(constructor_id));
-(((func)->linkage) =  parser::FunctionLinkage { typename parser::FunctionLinkage::External() } );
+if (TRY((types_match(((*this)),((((((((first)->params))[i])).variable))->type_id),((((((((second)->params))[i])).variable))->type_id))))){
 }
-
+else {
+return (false);
 }
+
 }
 
 }
 }
-else if ((!(((((parsed_record).definition_linkage)).index() == 1 /* External */)))){
-bool const constructor_can_throw = ((((parsed_record).record_type)).index() == 1 /* Class */);
-types::ScopeId const function_scope_id = TRY((((*this).create_scope(((struct_).scope_id),constructor_can_throw,TRY((__jakt_format(Jakt::DeprecatedString("generated-constructor({})"sv),((parsed_record).name)))),true))));
-types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,constructor_can_throw,TRY((__jakt_format(Jakt::DeprecatedString("generated-constructor-block({})"sv),((parsed_record).name)))),true))));
-NonnullRefPtr<types::CheckedFunction> checked_constructor = TRY((types::CheckedFunction::__jakt_create(((parsed_record).name),((parsed_record).name_span), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,struct_type_id,JaktInternal::OptionalNone(),(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),TRY((types::FunctionGenerics::__jakt_create(function_scope_id,(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false),constructor_can_throw, parser::FunctionType { typename parser::FunctionType::ImplicitConstructor() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,function_scope_id,struct_id,true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),((parsed_record).external_name),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::FunctionId const function_id = TRY((((module)->add_function(checked_constructor))));
-JaktInternal::DynamicArray<types::StructId> const inheritance_chain = TRY((((*this).struct_inheritance_chain(struct_id))));
-NonnullRefPtr<types::CheckedFunction> func = (((((module)->functions)).last()).value());
-{
-JaktInternal::ArrayIterator<types::StructId> _magic = ((inheritance_chain).iterator());
-for (;;){
-JaktInternal::Optional<types::StructId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::StructId field_struct_id = (_magic_value.value());
-{
-{
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((((*this).get_struct(field_struct_id))).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedField field = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const variable = ((*this).get_variable(((field).variable_id)));
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value = ((field).default_value);
-if (((!(((default_value).has_value()))) && ((((field).default_value_expression)).has_value()))){
-(((field).default_value) = TRY((((*this).typecheck_expression((((field).default_value_expression).value()),block_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,((variable)->type_id))))));
+
+return (true);
 }
-TRY((((func)->add_param(types::CheckedParameter(true,variable,((field).default_value))))));
+else {
+return (false);
 }
 
 }
+else {
+return (false);
 }
 
+}
+else {
+return (false);
 }
 
 }
 }
 
-TRY((((*this).add_function_to_scope(((struct_).scope_id),((parsed_record).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((parsed_record).name_span)))));
+ErrorOr<NonnullRefPtr<typename types::Type>> typechecker::Typechecker::unwrap_type_from_optional_if_needed(NonnullRefPtr<typename types::Type> const type) const {
+{
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+if (((type)->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((type)->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((type)->get<types::Type::GenericInstance>()).args;
+if (((id).equals(optional_struct_id))){
+return (((*this).get_type(((args)[static_cast<i64>(0LL)]))));
 }
-(((*this).current_struct_type_id) = JaktInternal::OptionalNone());
 }
-return {};
+return (type);
+}
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_enum_predecl_initial(parser::ParsedRecord const parsed_record,size_t const enum_index,size_t const module_enum_len,types::ScopeId const scope_id) {
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_guard(NonnullRefPtr<typename parser::ParsedExpression> const expr,parser::ParsedBlock const else_block,parser::ParsedBlock const remaining_code,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
 {
-types::ModuleId const module_id = ((*this).current_module_id);
-types::EnumId const enum_id = types::EnumId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(enum_index,module_enum_len)));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id)))))));
-types::TypeId const enum_type_id = types::TypeId(module_id,(JaktInternal::checked_sub<size_t>(((((((*this).current_module()))->types)).size()),static_cast<size_t>(1ULL))));
-TRY((((*this).add_type_to_scope(scope_id,((parsed_record).name),enum_type_id,((parsed_record).name_span)))));
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = enum_type_id);
-ScopeGuard __jakt_var_485([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
-bool const is_boxed = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((parsed_record).record_type);
+bool seen_scope_exit = false;
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((else_block).stmts)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename parser::ParsedStatement> statement = (_magic_value.value());
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
+auto&& __jakt_match_variant = *statement;
 switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::SumEnum>();bool const& is_boxed = __jakt_match_value.is_boxed;
-return JaktInternal::ExplicitValue(is_boxed);
+case 10: {
+{
+(seen_scope_exit = true);
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 11: {
+{
+(seen_scope_exit = true);
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 12: {
+{
+(seen_scope_exit = true);
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 13: {
+{
+(seen_scope_exit = true);
+return JaktInternal::LoopBreak{};
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(false);
+{
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-TRY((((((module)->enums)).push(types::CheckedEnum(((parsed_record).name),((parsed_record).name_span),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),(TRY((DynamicArray<types::CheckedEnumVariant>::create_with({})))),(TRY((DynamicArray<types::CheckedField>::create_with({})))),((*this).prelude_scope_id()),((parsed_record).definition_linkage),(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))),((parsed_record).record_type),enum_type_id,enum_type_id,is_boxed)))));
-}
-return {};
 }
 
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>>> typechecker::Typechecker::find_functions_with_name_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
-{
-return (TRY((((((*this).program))->find_functions_with_name_in_scope(parent_scope_id,function_name)))));
 }
 }
 
-ErrorOr<types::CheckedParameter> typechecker::Typechecker::typecheck_parameter(parser::ParsedParameter const parameter,types::ScopeId const scope_id,bool const first,JaktInternal::Optional<types::TypeId> const this_arg_type_id,JaktInternal::Optional<types::ScopeId> const check_scope) {
-{
-types::TypeId type_id = TRY((((*this).typecheck_typename(((((parameter).variable)).parsed_type),scope_id,((((parameter).variable)).name)))));
-if ((first && (((((parameter).variable)).name) == Jakt::DeprecatedString("this"sv)))){
-if (((this_arg_type_id).has_value())){
-(type_id = (this_arg_type_id.value()));
-}
-}
-NonnullRefPtr<types::CheckedVariable> const variable = TRY((types::CheckedVariable::__jakt_create(((((parameter).variable)).name),type_id,((((parameter).variable)).is_mutable),((((parameter).variable)).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_default_value = JaktInternal::OptionalNone();
-if (((((parameter).default_argument)).has_value())){
-NonnullRefPtr<typename types::CheckedExpression> checked_default_value_expr = TRY((((*this).typecheck_expression((((parameter).default_argument).value()),scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,type_id))));
-if (((checked_default_value_expr)->index() == 25 /* OptionalNone */)){
-utility::Span const expr_span = ((checked_default_value_expr)->get<types::CheckedExpression::OptionalNone>()).span;
-(checked_default_value_expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::OptionalNone>(expr_span,type_id))));
+types::CheckedBlock const checked_else_block = TRY((((*this).typecheck_block(else_block,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+if (((!(seen_scope_exit)) && ((((checked_else_block).control_flow)).may_return()))){
+TRY((((*this).error(Jakt::DeprecatedString("Else block of guard must either `return`, `break`, `continue`, or `throw`"sv),span))));
 }
-types::TypeId const default_value_type_id = ((checked_default_value_expr)->type());
-(checked_default_value = checked_default_value_expr);
-if ((!(TRY((((*this).check_types_for_compat(type_id,default_value_type_id,((((*this).generic_inferences))),((checked_default_value_expr)->span())))))))){
-(checked_default_value = JaktInternal::OptionalNone());
+JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const new_condition_new_then_block_new_else_statement_ = TRY((((*this).expand_context_for_bindings(expr,JaktInternal::OptionalNone(),remaining_code,TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(else_block,span))),span))));
+NonnullRefPtr<typename parser::ParsedExpression> const new_condition = ((new_condition_new_then_block_new_else_statement_).template get<0>());
+JaktInternal::Optional<parser::ParsedBlock> const new_then_block = ((new_condition_new_then_block_new_else_statement_).template get<1>());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const new_else_statement = ((new_condition_new_then_block_new_else_statement_).template get<2>());
+
+NonnullRefPtr<typename types::CheckedExpression> const checked_condition = TRY((((*this).typecheck_expression_and_dereference_if_needed(new_condition,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+if ((!(((((checked_condition)->type())).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
+TRY((((*this).error(Jakt::DeprecatedString("Condition must be a boolean expression"sv),((new_condition)->span())))));
 }
+types::CheckedBlock const checked_block = TRY((((*this).typecheck_block((new_then_block.value()),scope_id,safety_mode,JaktInternal::OptionalNone()))));
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> checked_else = JaktInternal::OptionalNone();
+if (((new_else_statement).has_value())){
+(checked_else = TRY((((*this).typecheck_statement((new_else_statement.value()),scope_id,safety_mode,JaktInternal::OptionalNone())))));
 }
-types::CheckedParameter const checked_parameter = types::CheckedParameter(((parameter).requires_label),variable,checked_default_value);
-if (((check_scope).has_value())){
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::VarId const var_id = TRY((((module)->add_variable(variable))));
-TRY((((*this).add_var_to_scope((check_scope.value()),((((parameter).variable)).name),var_id,((((parameter).variable)).span)))));
+if (((((checked_block).yielded_type)).has_value())){
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Yield>(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Match>(checked_condition,(TRY((DynamicArray<types::CheckedMatchCase>::create_with({ types::CheckedMatchCase { typename types::CheckedMatchCase::Expression((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Boolean>(true,span))), types::CheckedMatchBody { typename types::CheckedMatchBody::Expression(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Block>(checked_block,span,(((checked_block).yielded_type).value()))))) } ,span) } ,  types::CheckedMatchCase { typename types::CheckedMatchCase::CatchAll((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),false, types::CheckedMatchBody { typename types::CheckedMatchBody::Block(checked_else_block) } ,span) } })))),span,(((checked_block).yielded_type).value()),false))),span))));
 }
-return (checked_parameter);
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::If>(checked_condition,checked_block,checked_else,span))));
 }
 }
 
-ErrorOr<types::TypeId> typechecker::Typechecker::typecheck_generic_resolved_type(DeprecatedString const name,JaktInternal::DynamicArray<types::TypeId> const checked_inner_types,types::ScopeId const scope_id,utility::Span const span) {
+NonnullRefPtr<typename types::Type> typechecker::Typechecker::get_type(types::TypeId const id) const {
 {
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,name))));
-if (((struct_id).has_value())){
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>((struct_id.value()),checked_inner_types))))))));
+return (((((*this).program))->get_type(id)));
 }
-JaktInternal::Optional<types::EnumId> const enum_id = TRY((((((*this).program))->find_enum_in_scope(scope_id,name))));
-if (((enum_id).has_value())){
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericEnumInstance>((enum_id.value()),checked_inner_types))))))));
 }
-JaktInternal::Optional<types::TraitId> const trait_id = TRY((((((*this).program))->find_trait_in_scope(scope_id,name))));
-if (((trait_id).has_value())){
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericTraitInstance>((trait_id.value()),checked_inner_types))))))));
+
+ErrorOr<bool> typechecker::Typechecker::add_trait_to_scope(types::ScopeId const scope_id,DeprecatedString const trait_name,types::TraitId const trait_id,utility::Span const span) {
+{
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::TraitId> const found_trait_id = ((((scope)->traits)).get(trait_name));
+if ((((found_trait_id).has_value()) && (!((((found_trait_id.value())).equals(trait_id)))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of trait ‘{}’"sv),trait_name))),span))));
+return (false);
 }
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("could not find {}"sv),name))),span))));
-return (types::unknown_type_id());
+TRY((((((scope)->traits)).set(trait_name,trait_id))));
+return (true);
 }
 }
 
-types::BlockControlFlow typechecker::Typechecker::maybe_statement_control_flow(JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const statement,types::BlockControlFlow const other_branch) const {
+ErrorOr<JaktInternal::Optional<types::ScopeId>> typechecker::Typechecker::scope_lifetime_union(JaktInternal::Optional<types::ScopeId> const first,JaktInternal::Optional<types::ScopeId> const second) const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
-auto __jakt_enum_value = (((statement).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((*this).statement_control_flow((statement.value()))));
+if (((!(((first).has_value()))) || (!(((second).has_value()))))){
+return (JaktInternal::OptionalNone());
 }
-else {
-return JaktInternal::ExplicitValue(((other_branch).partial()));
+types::ScopeId const first_id = (first.value());
+types::ScopeId const second_id = (second.value());
+if (((first_id).equals(((*this).root_scope_id())))){
+return (second_id);
 }
-}()))
-);
+if (((second_id).equals(((*this).root_scope_id())))){
+return (first_id);
+}
+{
+JaktInternal::Optional<types::ScopeId> scope_id = static_cast<JaktInternal::Optional<types::ScopeId>>(first_id);
+while (((scope_id).has_value())){
+if ((((scope_id.value())).equals(second_id))){
+return (first_id);
+}
+(scope_id = ((TRY((((*this).get_scope((scope_id.value()))))))->parent));
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_jakt_main(parser::ParsedFunction const parsed_function,types::ScopeId const parent_scope_id) {
 {
-DeprecatedString const param_type_error = Jakt::DeprecatedString("Main function  must take a single array of strings as its parameter"sv);
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const func_ids = TRY((((*this).find_functions_with_name_in_scope(parent_scope_id,Jakt::DeprecatedString("main"sv)))));
-if (((((func_ids.value())).size()) > static_cast<size_t>(1ULL))){
-TRY((((*this).error(Jakt::DeprecatedString("Function 'main' declared multiple times."sv),((parsed_function).name_span)))));
+JaktInternal::Optional<types::ScopeId> scope_id = static_cast<JaktInternal::Optional<types::ScopeId>>(second_id);
+while (((scope_id).has_value())){
+if ((((scope_id.value())).equals(first_id))){
+return (second_id);
 }
-if ((((((parsed_function).params)).size()) > static_cast<size_t>(1ULL))){
-TRY((((*this).error(param_type_error,((parsed_function).name_span)))));
+(scope_id = ((TRY((((*this).get_scope((scope_id.value()))))))->parent));
 }
-if ((!(((((parsed_function).params)).is_empty())))){
-if (((((((((((parsed_function).params))[static_cast<i64>(0LL)])).variable)).parsed_type))->index() == 3 /* JaktArray */)){
-NonnullRefPtr<typename parser::ParsedType> const inner = ((((((((((parsed_function).params))[static_cast<i64>(0LL)])).variable)).parsed_type))->get<parser::ParsedType::JaktArray>()).inner;
-utility::Span const span = ((((((((((parsed_function).params))[static_cast<i64>(0LL)])).variable)).parsed_type))->get<parser::ParsedType::JaktArray>()).span;
-if (((inner)->index() == 0 /* Name */)){
-DeprecatedString const name = ((inner)->get<parser::ParsedType::Name>()).name;
-utility::Span const span = ((inner)->get<parser::ParsedType::Name>()).span;
-if ((name != Jakt::DeprecatedString("String"sv))){
-TRY((((*this).error(param_type_error,span))));
 }
+
+return (JaktInternal::OptionalNone());
 }
-else {
-TRY((((*this).error(param_type_error,span))));
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_destructuring_assignment(JaktInternal::DynamicArray<parser::ParsedVarDecl> const vars,NonnullRefPtr<typename parser::ParsedStatement> const var_decl,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+{
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> var_decls = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+NonnullRefPtr<typename types::CheckedStatement> const checked_tuple_var_decl = TRY((((*this).typecheck_statement(var_decl,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+types::TypeId expr_type_id = types::unknown_type_id();
+types::VarId tuple_var_id = types::VarId(types::ModuleId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL));
+if (((checked_tuple_var_decl)->index() == 3 /* VarDecl */)){
+types::VarId const var_id = ((checked_tuple_var_decl)->get<types::CheckedStatement::VarDecl>()).var_id;
+NonnullRefPtr<typename types::CheckedExpression> const init = ((checked_tuple_var_decl)->get<types::CheckedStatement::VarDecl>()).init;
+(expr_type_id = ((init)->type()));
+(tuple_var_id = var_id);
 }
 else {
-TRY((((*this).error(param_type_error,((parsed_function).name_span)))));
+TRY((((*this).error(Jakt::DeprecatedString("Destructuting assignment should be a variable declaration"sv),span))));
 }
 
+JaktInternal::DynamicArray<types::TypeId> inner_types = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+NonnullRefPtr<typename types::Type> const tuple_type = ((*this).get_type(expr_type_id));
+if (((tuple_type)->index() == 19 /* GenericInstance */)){
+JaktInternal::DynamicArray<types::TypeId> const args = ((tuple_type)->get<types::Type::GenericInstance>()).args;
+(inner_types = args);
 }
-DeprecatedString const return_type_error = Jakt::DeprecatedString("Main function  must return c_int"sv);
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((parsed_function).return_type);
-switch(__jakt_match_variant.index()) {
-case 13: {
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Tuple Type should be Generic Instance"sv),span))));
+}
+
+NonnullRefPtr<types::CheckedVariable> const tuple_variable = ((((*this).program))->get_variable(tuple_var_id));
+if ((((vars).size()) == ((inner_types).size()))){
 {
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((vars).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
+size_t i = (_magic_value.value());
 {
-if ((name != Jakt::DeprecatedString("c_int"sv))){
-TRY((((*this).error(return_type_error,span))));
+parser::ParsedVarDecl new_var = ((vars)[i]);
+(((new_var).parsed_type) = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Name>(TRY((((*this).type_name(((inner_types)[i]),false)))),span))));
+NonnullRefPtr<typename parser::ParsedExpression> const init = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::IndexedTuple>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(((tuple_variable)->name),span))),i,false,span)));
+TRY((((var_decls).push(TRY((((*this).typecheck_var_decl(((vars)[i]),init,scope_id,safety_mode,span))))))));
+}
+
 }
 }
-return JaktInternal::ExplicitValue<void>();
+
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Tuple inner types sould have same size as tuple members"sv),span))));
+}
+
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::DestructuringAssignment>(var_decls,checked_tuple_var_decl,span))));
+}
+}
+
+ErrorOr<bool> typechecker::Typechecker::is_scope_directly_accessible_from(types::ScopeId const scope_id,types::ScopeId const from_scope_id) const {
+{
+return (TRY((((((*this).program))->is_scope_directly_accessible_from(scope_id,from_scope_id)))));
+}
+}
+
+ErrorOr<void> typechecker::Typechecker::typecheck_struct_default_fields(parser::ParsedRecord const parsed_record,types::StructId const struct_id,types::ScopeId const scope_id) {
+{
+types::CheckedStruct structure = ((*this).get_struct(struct_id));
+types::ScopeId const checked_struct_scope_id = ((structure).scope_id);
+types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
+JaktInternal::Optional<types::TypeId> const previous_struct_type_id = ((*this).current_struct_type_id);
+(((*this).current_struct_type_id) = struct_type_id);
+ScopeGuard __jakt_var_450([&] {
+{
+(((*this).current_struct_type_id) = previous_struct_type_id);
+}
+
+});
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = struct_type_id);
+ScopeGuard __jakt_var_451([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+JaktInternal::DynamicArray<parser::ParsedField> const parsed_fields = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<parser::ParsedField>, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((parsed_record).record_type);
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Struct>();JaktInternal::DynamicArray<parser::ParsedField> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(fields);
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Class>();JaktInternal::DynamicArray<parser::ParsedField> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(fields);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(return_type_error,((parsed_function).return_type_span)))));
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_struct_default_fields cannot handle non-structs"sv)))));
 }
-return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-}
-return {};
-}
-
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_for(DeprecatedString const iterator_name,utility::Span const name_span,bool const is_destructuring,NonnullRefPtr<typename parser::ParsedExpression> const range,parser::ParsedBlock const block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+i64 index = static_cast<i64>(0LL);
 {
-JaktInternal::Optional<utility::Span> const maybe_span = ((block).find_yield_span());
-if (((maybe_span).has_value())){
-TRY((((*this).error(Jakt::DeprecatedString("a 'for' loop block is not allowed to yield values"sv),(maybe_span.value())))));
+JaktInternal::ArrayIterator<parser::ParsedField> _magic = ((parsed_fields).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-NonnullRefPtr<typename types::CheckedExpression> iterable_expr = TRY((((*this).typecheck_expression(range,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-types::TypeId resolved_iterable_result_type = types::unknown_type_id();
-NonnullRefPtr<typename parser::ParsedExpression> expression_to_iterate = range;
-JaktInternal::Optional<typechecker::TraitImplementationDescriptor> const iterable_trait_implementation = TRY((((*this).find_any_singular_trait_implementation(((iterable_expr)->type()),(TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("Iterable"sv), Jakt::DeprecatedString("ThrowingIterable"sv)})))),scope_id,((iterable_expr)->span())))));
-if ((!(((iterable_trait_implementation).has_value())))){
-JaktInternal::Optional<typechecker::TraitImplementationDescriptor> const into_iterator_trait_implementation = TRY((((*this).find_any_singular_trait_implementation(((iterable_expr)->type()),(TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("IntoIterator"sv), Jakt::DeprecatedString("IntoThrowingIterator"sv)})))),scope_id,((iterable_expr)->span())))));
-if ((!(((into_iterator_trait_implementation).has_value())))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Iterable expression is not iterable"sv),((range)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Consider implementing (Throwing)Iterable<T> or Into(Throwing)Iterator<T> for the type of this expression (‘{}’)"sv),TRY((((*this).type_name(((iterable_expr)->type()),false))))))),((range)->span())))));
+parser::ParsedField unchecked_member = (_magic_value.value());
+{
+ScopeGuard __jakt_var_452([&] {
+({auto& _jakt_ref = index;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
+});
+if (((!(((((unchecked_member).default_value)).has_value()))) || ((((((((structure).fields))[index])).default_value)).has_value()))){
+continue;
 }
-else {
-(resolved_iterable_result_type = (((((into_iterator_trait_implementation.value())).implemented_type_args))[static_cast<i64>(0LL)]));
-(expression_to_iterate = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(range,parser::ParsedCall((TRY((DynamicArray<DeprecatedString>::create_with({})))),Jakt::DeprecatedString("iterator"sv),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))))),false,name_span))));
+(((((((structure).fields))[index])).default_value) = TRY((((*this).typecheck_expression((((unchecked_member).default_value).value()),checked_struct_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone())))));
 }
 
 }
-else {
-(resolved_iterable_result_type = (((((iterable_trait_implementation.value())).implemented_type_args))[static_cast<i64>(0LL)]));
 }
 
-NonnullRefPtr<typename parser::ParsedStatement> const rewritten_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(parser::ParsedVarDecl(Jakt::DeprecatedString("_magic"sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),true,JaktInternal::OptionalNone(),name_span),expression_to_iterate,span))), TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Loop>(parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(parser::ParsedVarDecl(Jakt::DeprecatedString("_magic_value"sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),false,JaktInternal::OptionalNone(),name_span),TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("_magic"sv),name_span))),parser::ParsedCall((TRY((DynamicArray<DeprecatedString>::create_with({})))),Jakt::DeprecatedString("next"sv),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))))),false,name_span))),span))), TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::If>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("_magic_value"sv),name_span))),parser::ParsedCall((TRY((DynamicArray<DeprecatedString>::create_with({})))),Jakt::DeprecatedString("has_value"sv),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))))),false,name_span))), parser::UnaryOperator { typename parser::UnaryOperator::LogicalNot() } ,name_span))),parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Break>(span)))}))))),JaktInternal::OptionalNone(),span))), TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(parser::ParsedVarDecl(iterator_name,TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),true,JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<utility::Span>,ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
-auto __jakt_enum_value = (is_destructuring);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-}
-else {
-return JaktInternal::ExplicitValue(name_span);
-}
-}()))
-,name_span),TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::ForcedUnwrap>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("_magic_value"sv),name_span))),name_span))),span))), TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(block,span)))}))))),span)))}))))),span)));
-return (TRY((((*this).typecheck_statement(rewritten_statement,scope_id,safety_mode,JaktInternal::OptionalNone())))));
 }
+return {};
 }
 
 ErrorOr<void> typechecker::Typechecker::typecheck_namespace_constructors(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
@@ -7389,580 +7052,587 @@ return JaktInternal::ExplicitValue<void>();
 return {};
 }
 
-bool typechecker::Typechecker::is_floating(types::TypeId const type_id) const {
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_block_statement(parser::ParsedBlock const parsed_block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
 {
-return (((((*this).program))->is_floating(type_id)));
+types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(parsed_block,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+if (((((checked_block).yielded_type)).has_value())){
+TRY((((*this).error(Jakt::DeprecatedString("A block used as a statement cannot yield values, as the value cannot be observed in any way"sv),(((parsed_block).find_yield_span()).value())))));
+}
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Block>(checked_block,span))));
 }
 }
 
-ErrorOr<JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>>> typechecker::Typechecker::typecheck_match_body(parser::ParsedMatchBody const body,types::ScopeId const scope_id,types::SafetyMode const safety_mode,types::GenericInferences& generic_inferences,JaktInternal::Optional<types::TypeId> const final_result_type,utility::Span const span) {
+ErrorOr<types::FunctionId> typechecker::Typechecker::typecheck_function_predecl(parser::ParsedFunction const parsed_function,types::ScopeId const parent_scope_id,JaktInternal::Optional<types::TypeId> const this_arg_type_id,JaktInternal::Optional<NonnullRefPtr<types::FunctionGenerics>> generics) {
 {
-JaktInternal::Optional<types::TypeId> result_type = final_result_type;
-types::CheckedMatchBody const checked_match_body = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedMatchBody, ErrorOr<JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>>>>{
-auto&& __jakt_match_variant = body;
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchBody::Block>();
-parser::ParsedBlock const& block = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::CheckedMatchBody> __jakt_var_486; {
-types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(block,scope_id,safety_mode,final_result_type))));
-if ((((((checked_block).control_flow)).may_return()) || ((((checked_block).yielded_type)).has_value()))){
-types::TypeId const block_type_id = ((checked_block).yielded_type).value_or_lazy_evaluated([&] { return types::void_type_id(); });
-utility::Span const yield_span = ((block).find_yield_span()).value_or_lazy_evaluated([&] { return span; });
-if (((result_type).has_value())){
-TRY((((*this).check_types_for_compat((result_type.value()),block_type_id,generic_inferences,yield_span))));
+types::ScopeId const function_scope_id = TRY((((*this).create_scope(parent_scope_id,((parsed_function).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("fn({})"sv),((parsed_function).name)))),true))));
+DeprecatedString const scope_debug_name = TRY((__jakt_format(Jakt::DeprecatedString("function-block({})"sv),((parsed_function).name))));
+types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,((parsed_function).can_throw),scope_debug_name,true))));
+size_t const module_id = ((((*this).current_module_id)).id);
+bool base_definition = false;
+if ((!(((generics).has_value())))){
+(generics = TRY((types::FunctionGenerics::__jakt_create(function_scope_id,(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))));
+(base_definition = true);
+}
+bool const is_generic_function = (!(((((parsed_function).generic_parameters)).is_empty())));
+bool const is_generic = (is_generic_function || (((this_arg_type_id).has_value()) && ((((*this).get_type((this_arg_type_id.value()))))->index() == 19 /* GenericInstance */)));
+NonnullRefPtr<types::CheckedFunction> checked_function = TRY((types::CheckedFunction::__jakt_create(((parsed_function).name),((parsed_function).name_span),TRY((((*this).typecheck_visibility(((parsed_function).visibility),parent_scope_id)))),types::unknown_type_id(),((parsed_function).return_type_span),(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),(generics.value()),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false),((parsed_function).can_throw),((parsed_function).type),((parsed_function).linkage),function_scope_id,JaktInternal::OptionalNone(),((!(is_generic)) || (!(base_definition))),parsed_function,((parsed_function).is_comptime),false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),((parsed_function).external_name),((parsed_function).deprecated_message),JaktInternal::OptionalNone())));
+NonnullRefPtr<types::Module> current_module = ((*this).current_module());
+types::FunctionId const function_id = TRY((((current_module)->add_function(checked_function))));
+types::ScopeId const checked_function_scope_id = ((checked_function)->function_scope_id);
+bool const external_linkage = ((((parsed_function).linkage)).index() == 1 /* External */);
+JaktInternal::Optional<types::ScopeId> const check_scope = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>,ErrorOr<types::FunctionId>>{
+auto __jakt_enum_value = ((is_generic || ((((parsed_function).return_type))->index() == 13 /* Empty */)));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::ScopeId>>(TRY((((*this).create_scope(parent_scope_id,((parsed_function).can_throw),scope_debug_name,true))))));
 }
 else {
-(result_type = block_type_id);
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
 }
-
+}()))
+;
+i64 i = static_cast<i64>(0LL);
+{
+JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((parsed_function).generic_parameters)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-JaktInternal::Optional<types::CheckedMatchBody> final_body = JaktInternal::OptionalNone();
-if ((((((checked_block).yielded_type)).has_value()) && (!(((((checked_block).control_flow)).never_returns()))))){
-(final_body =  types::CheckedMatchBody { typename types::CheckedMatchBody::Expression(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Block>(checked_block,span,(((checked_block).yielded_type).value()))))) } );
+parser::ParsedGenericParameter generic_parameter = (_magic_value.value());
+{
+types::TypeId type_var_type_id = types::TypeId(((current_module)->id),((((current_module)->types)).size()));
+if (base_definition){
+types::FunctionGenericParameter parameter = TRY((types::FunctionGenericParameter::parameter(type_var_type_id,((generic_parameter).span))));
+JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((((current_module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((generic_parameter).name),trait_implementations)))))));
+if (((((generic_parameter).requires_list)).has_value())){
+TRY((((*this).fill_trait_requirements((((generic_parameter).requires_list).value()),((((((parameter).checked_parameter)).constraints))),((trait_implementations)),parent_scope_id))));
 }
-else {
-(final_body =  types::CheckedMatchBody { typename types::CheckedMatchBody::Block(checked_block) } );
+TRY((((((((checked_function)->generics))->params)).push(parameter))));
 }
-
-__jakt_var_486 = (final_body.value()); goto __jakt_label_447;
-
+else if (((((((((((checked_function)->generics))->params))[i])).kind)).index() == 1 /* Parameter */)){
+(type_var_type_id = ((((((((checked_function)->generics))->params))[i])).type_id()));
 }
-__jakt_label_447:; __jakt_var_486.release_value(); }));
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedMatchBody::Expression>();
-NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<types::CheckedMatchBody> __jakt_var_487; {
-NonnullRefPtr<typename types::CheckedExpression> const checked_expression = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,result_type))));
-if (((result_type).has_value())){
-TRY((((*this).check_types_for_compat((result_type.value()),((checked_expression)->type()),generic_inferences,span))));
+if (((!(((parsed_function).must_instantiate))) || external_linkage)){
+TRY((((*this).add_type_to_scope(checked_function_scope_id,((generic_parameter).name),type_var_type_id,((generic_parameter).span)))));
 }
-else {
-(result_type = ((checked_expression)->type()));
+if (((check_scope).has_value())){
+TRY((((*this).add_type_to_scope((check_scope.value()),((generic_parameter).name),type_var_type_id,((generic_parameter).span)))));
 }
-
-__jakt_var_487 =  types::CheckedMatchBody { typename types::CheckedMatchBody::Expression(checked_expression) } ; goto __jakt_label_448;
-
+((i++));
 }
-__jakt_label_448:; __jakt_var_487.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-return ((Tuple{checked_match_body, result_type}));
+
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_throw(NonnullRefPtr<typename parser::ParsedExpression> const expr,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+bool first = true;
+NonnullRefPtr<types::Module> module = ((*this).current_module());
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-types::TypeId const error_type_id = TRY((((*this).find_type_in_prelude(Jakt::DeprecatedString("Error"sv)))));
-if ((!(((((checked_expr)->type())).equals(error_type_id))))){
-TRY((((*this).error(Jakt::DeprecatedString("throw expression does not produce an error"sv),((expr)->span())))));
+JaktInternal::ArrayIterator<parser::ParsedParameter> _magic = ((((parsed_function).params)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
-if ((!(((scope)->can_throw)))){
-TRY((((*this).error(Jakt::DeprecatedString("Throw statement needs to be in a try statement or a function marked as throws"sv),((expr)->span())))));
+parser::ParsedParameter parameter = (_magic_value.value());
+{
+types::CheckedParameter const checked_param = TRY((((*this).typecheck_parameter(parameter,checked_function_scope_id,first,this_arg_type_id,check_scope))));
+TRY((((((checked_function)->params)).push(checked_param))));
+if (base_definition){
+TRY((((((((checked_function)->generics))->base_params)).push(checked_param))));
 }
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Throw>(checked_expr,span))));
+(first = false);
+}
+
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_set(JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const values,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
+if (((((parsed_function).stores_arguments)).has_value())){
 {
-if (((*this).dump_try_hints)){
-TRY((((*this).dump_try_hint(span))));
-}
-if ((!(((TRY((((*this).get_scope(scope_id)))))->can_throw)))){
-TRY((((*this).error(Jakt::DeprecatedString("Set initialization needs to be in a try statement or a function marked as throws"sv),span))));
+JaktInternal::ArrayIterator<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> _magic = (((((parsed_function).stores_arguments).value())).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-types::TypeId inner_type_id = types::unknown_type_id();
-JaktInternal::Optional<utility::Span> inner_type_span = JaktInternal::OptionalNone();
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> output = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedExpression>>::create_with({}))));
-types::StructId const set_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Set"sv)))));
-JaktInternal::Optional<types::TypeId> inner_hint = JaktInternal::OptionalNone();
-JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const type_hint_ids = TRY((((*this).get_type_ids_from_type_hint_if_struct_ids_match(type_hint,set_struct_id))));
-if (((type_hint_ids).has_value())){
-(inner_hint = (((type_hint_ids.value()))[static_cast<i64>(0LL)]));
+JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel> index_____ = (_magic_value.value());
+{
+JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel> const jakt__index_____ = index_____;
+size_t const index = ((jakt__index_____).template get<0>());
+parser::ArgumentStoreLevel const _ = ((jakt__index_____).template get<1>());
+
+if ((index >= ((((checked_function)->params)).size()))){
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("stores_argument() index out of bounds"sv)))));
 }
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<types::FunctionId>>{
+auto&& __jakt_match_variant = *((*this).get_type(((((((((checked_function)->params))[index])).variable))->type_id)));
+switch(__jakt_match_variant.index()) {
+case 27: {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedExpression>> _magic = ((values).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-NonnullRefPtr<typename parser::ParsedExpression> value = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 28: {
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_value = TRY((((*this).typecheck_expression(value,scope_id,safety_mode,inner_hint))));
-types::TypeId const current_value_type_id = ((checked_value)->type());
-if (((inner_type_id).equals(types::unknown_type_id()))){
-if ((((current_value_type_id).equals(types::void_type_id())) || ((current_value_type_id).equals(types::unknown_type_id())))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot create a set with values of type void"sv),((value)->span())))));
 }
-(inner_type_id = current_value_type_id);
-(inner_type_span = ((value)->span()));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("This parameter is not a reference"sv),((((((((checked_function)->params))[index])).variable))->definition_span),Jakt::DeprecatedString("stores_argument() may only be used to declare reference lifetime requirements"sv),((((((((checked_function)->params))[index])).variable))->definition_span)))));
 }
-else if ((!(((inner_type_id).equals(current_value_type_id))))){
-DeprecatedString const set_type_name = TRY((((*this).type_name(inner_type_id,false))));
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' does not match type '{}' of previous values in set"sv),TRY((((*this).type_name(current_value_type_id,false)))),set_type_name))),((value)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Set was inferred to store type '{}' here"sv),set_type_name))),(inner_type_span.value())))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+}
+
 }
-TRY((((output).push(checked_value))));
 }
 
 }
+(((checked_function)->stores_arguments) = ((parsed_function).stores_arguments));
+types::TypeId function_return_type_id = TRY((((*this).typecheck_typename(((parsed_function).return_type),checked_function_scope_id,JaktInternal::OptionalNone()))));
+if (((((parsed_function).return_type))->index() == 13 /* Empty */)){
+if (((parsed_function).is_fat_arrow)){
+bool const old_ignore_errors = ((*this).ignore_errors);
+(((*this).ignore_errors) = true);
+types::CheckedBlock const block = TRY((((*this).typecheck_block(((parsed_function).block),(check_scope.value()), types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
+if (((*this).had_an_error)){
+(function_return_type_id = types::void_type_id());
+(((*this).ignore_errors) = false);
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Can't infer the return type of this function"sv),((parsed_function).return_type_span),Jakt::DeprecatedString("Try adding an explicit return type to the function here"sv),((parsed_function).return_type_span)))));
+}
+else {
+(function_return_type_id = ((*this).infer_function_return_type(block)));
 }
 
-if (((inner_type_id).equals(types::unknown_type_id()))){
-if (((inner_hint).has_value())){
-(inner_type_id = (inner_hint.value()));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Cannot infer generic type for Set<T>"sv),span))));
+(function_return_type_id = types::void_type_id());
 }
 
 }
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(set_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id})))))))))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::JaktSet>(output,span,type_id,inner_type_id))));
+(((checked_function)->return_type_id) = function_return_type_id);
+TRY((((*this).check_that_type_doesnt_contain_reference(function_return_type_id,((parsed_function).return_type_span)))));
+if (((!(((((parsed_function).generic_parameters)).is_empty()))) && ((function_return_type_id).equals(types::unknown_type_id())))){
+bool const old_ignore_errors = ((*this).ignore_errors);
+(((*this).ignore_errors) = true);
+types::CheckedBlock const block = TRY((((*this).typecheck_block(((parsed_function).block),(check_scope.value()), types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
+types::TypeId const return_type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId,ErrorOr<types::FunctionId>>{
+auto __jakt_enum_value = (((function_return_type_id).equals(types::unknown_type_id())));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((*this).infer_function_return_type(block)));
+}
+else {
+return JaktInternal::ExplicitValue(TRY((((*this).resolve_type_var(function_return_type_id,parent_scope_id)))));
+}
+}()))
+;
+(((checked_function)->block) = block);
+(((checked_function)->return_type_id) = return_type_id);
+}
+TRY((((*this).add_function_to_scope(parent_scope_id,((parsed_function).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((parsed_function).name_span)))));
+return (function_id);
 }
 }
 
-bool typechecker::Typechecker::is_integer(types::TypeId const type_id) const {
+ErrorOr<types::TypeId> typechecker::Typechecker::find_or_add_type_id(NonnullRefPtr<typename types::Type> const type) {
 {
-return (((((*this).program))->is_integer(type_id)));
+return (TRY((((((*this).program))->find_or_add_type_id(type,((*this).current_module_id))))));
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_namespace_aliases(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id,typechecker::ImportRestrictions const allow) {
-{
-JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
+ErrorOr<typechecker::Typechecker> typechecker::Typechecker::typecheck(NonnullRefPtr<compiler::Compiler> compiler,parser::ParsedNamespace const parsed_namespace) {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::Optional<utility::FileId> const input_file = ((compiler)->current_file);
+if ((!(((input_file).has_value())))){
+TRY((((compiler)->panic(Jakt::DeprecatedString("trying to typecheck a non-existant file"sv)))));
+}
+DeprecatedString const true_module_name = TRY((((((((compiler)->files))[(((input_file.value())).id)])).basename(true))));
+types::ModuleId const placeholder_module_id = types::ModuleId(static_cast<size_t>(0ULL));
+DeprecatedString const root_module_name = TRY(((((((compiler)->current_file_path()).value())).basename(true))));
+typechecker::Typechecker typechecker = typechecker::Typechecker(compiler,TRY((types::CheckedProgram::__jakt_create(compiler,(TRY((DynamicArray<NonnullRefPtr<types::Module>>::create_with({})))),(TRY((Dictionary<DeprecatedString, types::LoadedModule>::create_with_entries({}))))))),placeholder_module_id,types::TypeId::none(),JaktInternal::OptionalNone(),false,static_cast<size_t>(0ULL),false,((compiler)->dump_type_hints),((compiler)->dump_try_hints),static_cast<u64>(0ULL),types::GenericInferences((TRY((Dictionary<DeprecatedString, DeprecatedString>::create_with_entries({}))))),JaktInternal::OptionalNone(),root_module_name,false,false);
+TRY((((typechecker).include_prelude())));
+types::ModuleId const root_module_id = TRY((((typechecker).create_module(root_module_name,true,JaktInternal::OptionalNone()))));
+(((typechecker).current_module_id) = root_module_id);
+((compiler)->set_current_file((input_file.value())));
+types::LoadedModule const loaded_module = types::LoadedModule(root_module_id,(input_file.value()));
+TRY((((((typechecker).program))->set_loaded_module(true_module_name,loaded_module))));
+types::ScopeId const PRELUDE_SCOPE_ID = ((typechecker).prelude_scope_id());
+types::ScopeId const root_scope_id = TRY((((typechecker).create_scope(PRELUDE_SCOPE_ID,false,Jakt::DeprecatedString("root"sv),false))));
+TRY((((typechecker).typecheck_module_import(parser::ParsedModuleImport( parser::ImportName { typename parser::ImportName::Literal(Jakt::DeprecatedString("jakt::prelude::prelude"sv),utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL))) } ,JaktInternal::OptionalNone(), parser::ImportList { typename parser::ImportList::All() } ),root_scope_id))));
+TRY((((typechecker).typecheck_module(parsed_namespace,root_scope_id))));
+return (typechecker);
 }
-size_t i = (_magic_value.value());
-{
-parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
-types::ScopeId const child_namespace_scope_id = ((children)[i]);
-TRY((((*this).typecheck_namespace_aliases(child_namespace,child_namespace_scope_id,allow))));
 }
 
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>>> typechecker::Typechecker::typecheck_enum_variant_bindings(types::CheckedEnumVariant const variant,JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const bindings,utility::Span const span) {
+{
+if (((variant).index() == 1 /* Typed */)){
+types::TypeId const type_id = ((variant).get<types::CheckedEnumVariant::Typed>()).type_id;
+if ((((bindings).size()) != static_cast<size_t>(1ULL))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant ‘{}’ must have exactly one argument"sv),((variant).name())))),span))));
+return (JaktInternal::OptionalNone());
 }
+return ((TRY((DynamicArray<types::CheckedEnumVariantBinding>::create_with({types::CheckedEnumVariantBinding(JaktInternal::OptionalNone(),((((bindings)[static_cast<i64>(0LL)])).binding),type_id,span)})))));
 }
-
+if (((variant).index() == 3 /* StructLike */)){
+JaktInternal::DynamicArray<types::VarId> const fields = ((variant).get<types::CheckedEnumVariant::StructLike>()).fields;
+JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> checked_vars = (TRY((DynamicArray<NonnullRefPtr<types::CheckedVariable>>::create_with({}))));
+JaktInternal::DynamicArray<types::CheckedEnumVariantBinding> checked_enum_variant_bindings = (TRY((DynamicArray<types::CheckedEnumVariantBinding>::create_with({}))));
 {
-JaktInternal::ArrayIterator<parser::ParsedAlias> _magic = ((((parsed_namespace).aliases)).iterator());
+JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedAlias> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedAlias alias = (_magic_value.value());
+types::VarId field = (_magic_value.value());
 {
-TRY((((*this).typecheck_alias(alias,scope_id,allow))));
-}
-
-}
+TRY((((checked_vars).push(((*this).get_variable(field))))));
 }
 
 }
-return {};
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_guard(NonnullRefPtr<typename parser::ParsedExpression> const expr,parser::ParsedBlock const else_block,parser::ParsedBlock const remaining_code,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
-{
-bool seen_scope_exit = false;
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((else_block).stmts)).iterator());
+JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = ((bindings).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedStatement> statement = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
-auto&& __jakt_match_variant = *statement;
-switch(__jakt_match_variant.index()) {
-case 10: {
-{
-(seen_scope_exit = true);
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 11: {
-{
-(seen_scope_exit = true);
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 12: {
+parser::EnumVariantPatternArgument binding = (_magic_value.value());
 {
-(seen_scope_exit = true);
-return JaktInternal::LoopBreak{};
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 13: {
 {
-(seen_scope_exit = true);
-return JaktInternal::LoopBreak{};
+JaktInternal::ArrayIterator<NonnullRefPtr<types::CheckedVariable>> _magic = ((checked_vars).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+NonnullRefPtr<types::CheckedVariable> var = (_magic_value.value());
 {
+DeprecatedString const binding_name = ((binding).name).value_or_lazy_evaluated([&] { return ((binding).binding); });
+types::TypeId const type_id = ((var)->type_id);
+if ((binding_name == ((var)->name))){
+TRY((((checked_enum_variant_bindings).push(types::CheckedEnumVariantBinding(((binding).name),((binding).binding),type_id,span)))));
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
 }
 
 }
 }
 
-types::CheckedBlock const checked_else_block = TRY((((*this).typecheck_block(else_block,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-if (((!(seen_scope_exit)) && ((((checked_else_block).control_flow)).may_return()))){
-TRY((((*this).error(Jakt::DeprecatedString("Else block of guard must either `return`, `break`, `continue`, or `throw`"sv),span))));
 }
-JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const new_condition_new_then_block_new_else_statement_ = TRY((((*this).expand_context_for_bindings(expr,JaktInternal::OptionalNone(),remaining_code,TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(else_block,span))),span))));
-NonnullRefPtr<typename parser::ParsedExpression> const new_condition = ((new_condition_new_then_block_new_else_statement_).template get<0>());
-JaktInternal::Optional<parser::ParsedBlock> const new_then_block = ((new_condition_new_then_block_new_else_statement_).template get<1>());
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const new_else_statement = ((new_condition_new_then_block_new_else_statement_).template get<2>());
 
-NonnullRefPtr<typename types::CheckedExpression> const checked_condition = TRY((((*this).typecheck_expression_and_dereference_if_needed(new_condition,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-if ((!(((((checked_condition)->type())).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
-TRY((((*this).error(Jakt::DeprecatedString("Condition must be a boolean expression"sv),((new_condition)->span())))));
 }
-types::CheckedBlock const checked_block = TRY((((*this).typecheck_block((new_then_block.value()),scope_id,safety_mode,JaktInternal::OptionalNone()))));
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> checked_else = JaktInternal::OptionalNone();
-if (((new_else_statement).has_value())){
-(checked_else = TRY((((*this).typecheck_statement((new_else_statement.value()),scope_id,safety_mode,JaktInternal::OptionalNone())))));
 }
-if (((((checked_block).yielded_type)).has_value())){
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Yield>(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Match>(checked_condition,(TRY((DynamicArray<types::CheckedMatchCase>::create_with({ types::CheckedMatchCase { typename types::CheckedMatchCase::Expression((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Boolean>(true,span))), types::CheckedMatchBody { typename types::CheckedMatchBody::Expression(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Block>(checked_block,span,(((checked_block).yielded_type).value()))))) } ,span) } ,  types::CheckedMatchCase { typename types::CheckedMatchCase::CatchAll((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),false, types::CheckedMatchBody { typename types::CheckedMatchBody::Block(checked_else_block) } ,span) } })))),span,(((checked_block).yielded_type).value()),false))),span))));
+
+if ((((checked_enum_variant_bindings).size()) > static_cast<size_t>(0ULL))){
+return (checked_enum_variant_bindings);
 }
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::If>(checked_condition,checked_block,checked_else,span))));
+return (JaktInternal::OptionalNone());
 }
+else {
+return (JaktInternal::OptionalNone());
 }
 
-ErrorOr<bool> typechecker::Typechecker::add_comptime_binding_to_scope(types::ScopeId const scope_id,DeprecatedString const name,types::Value const value,utility::Span const span) {
-{
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::Value> const existing_binding = ((((scope)->comptime_bindings)).get(name));
-if (((existing_binding).has_value())){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of comptime variable ‘{}’"sv),name))),span,Jakt::DeprecatedString("previous definition here"sv),(((existing_binding.value())).span)))));
-}
-TRY((((((scope)->comptime_bindings)).set(name,value))));
-return (true);
 }
 }
 
-ErrorOr<bool> typechecker::Typechecker::add_trait_to_scope(types::ScopeId const scope_id,DeprecatedString const trait_name,types::TraitId const trait_id,utility::Span const span) {
+ErrorOr<void> typechecker::Typechecker::typecheck_struct(parser::ParsedRecord const record,types::StructId const struct_id,types::ScopeId const parent_scope_id) {
 {
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::TraitId> const found_trait_id = ((((scope)->traits)).get(trait_name));
-if ((((found_trait_id).has_value()) && (!((((found_trait_id.value())).equals(trait_id)))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of trait ‘{}’"sv),trait_name))),span))));
-return (false);
-}
-TRY((((((scope)->traits)).set(trait_name,trait_id))));
-return (true);
-}
-}
-
-ErrorOr<bool> typechecker::Typechecker::signatures_match(types::TypeId const self_type_id,NonnullRefPtr<types::CheckedFunction> const first,NonnullRefPtr<types::CheckedFunction> const second) {
-{
-Function<ErrorOr<bool>(typechecker::Typechecker&, types::TypeId, types::TypeId)> const types_match = [self_type_id](typechecker::Typechecker& typechecker, types::TypeId a, types::TypeId b) -> ErrorOr<bool> {
-{
-types::TypeId const mapped_a = TRY((((((((typechecker))).generic_inferences)).map(a))));
-types::TypeId const mapped_b = TRY((((((((typechecker))).generic_inferences)).map(b))));
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<bool>>{
-auto&& __jakt_match_variant = *((((typechecker))).get_type(mapped_a));
-switch(__jakt_match_variant.index()) {
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
-types::TraitId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((((typechecker))).implements_trait(mapped_b,id,JaktInternal::OptionalNone())))));
-};/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_488; {
-bool const old_ignore_errors = ((((typechecker))).ignore_errors);
-(((((typechecker))).ignore_errors) = true);
-ScopeGuard __jakt_var_489([&] {
-{
-(((((typechecker))).ignore_errors) = old_ignore_errors);
-(((((typechecker))).had_an_error) = false);
-}
-
+types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
+(((*this).current_struct_type_id) = struct_type_id);
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = struct_type_id);
+ScopeGuard __jakt_var_453([&] {
+(((*this).self_type_id) = old_self_type_id);
 });
-__jakt_var_488 = TRY((((((typechecker))).check_types_for_compat(self_type_id,mapped_b,((((((typechecker))).generic_inferences))),utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)))))); goto __jakt_label_449;
-
-}
-__jakt_label_449:; __jakt_var_488.release_value(); }));
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(TRY((((((typechecker))).implements_trait(mapped_b,id,args)))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_490; {
-bool const old_ignore_errors = ((((typechecker))).ignore_errors);
-(((((typechecker))).ignore_errors) = true);
-ScopeGuard __jakt_var_491([&] {
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>>> all_virtuals = (TRY((Dictionary<DeprecatedString, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>>>::create_with_entries({}))));
+JaktInternal::Optional<types::StructId> super_struct_id = ((((*this).get_struct(struct_id))).super_struct_id);
+while (((super_struct_id).has_value())){
+types::CheckedStruct const super_struct = ((*this).get_struct((super_struct_id.value())));
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(((super_struct).scope_id)))));
 {
-(((((typechecker))).ignore_errors) = old_ignore_errors);
-(((((typechecker))).had_an_error) = false);
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
+DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
 
-});
-__jakt_var_490 = TRY((((((typechecker))).check_types_for_compat(mapped_a,mapped_b,((((((typechecker))).generic_inferences))),utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)))))); goto __jakt_label_450;
-
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_450:; __jakt_var_490.release_value(); }));
-};/*case end*/
-}/*switch end*/
-}()
-)));
+types::FunctionId function_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
+if (((function)->is_virtual)){
+if ((!(((all_virtuals).contains(((function)->name)))))){
+TRY(all_virtuals.set(((function)->name), (TRY((DynamicArray<NonnullRefPtr<types::CheckedFunction>>::create_with({function}))))));
 }
+else {
+TRY((((((all_virtuals)[((function)->name)])).push(function))));
 }
-;
-if (TRY((types_match(((*this)),((first)->return_type_id),((second)->return_type_id))))){
-if ((((first)->can_throw) == ((second)->can_throw))){
-if ((((((first)->params)).size()) == ((((second)->params)).size()))){
-size_t arg_start = static_cast<size_t>(0ULL);
-if (((first)->is_static())){
-if (((second)->is_static())){
+
 }
-else {
-return (false);
 }
 
 }
-else {
-if ((!(((second)->is_static())))){
-if ((((first)->is_mutating()) == ((second)->is_mutating()))){
-(arg_start = static_cast<size_t>(1ULL));
 }
-else {
-return (false);
+
 }
 
 }
-else {
-return (false);
 }
 
+(super_struct_id = ((super_struct).super_struct_id));
 }
-
+typechecker::TraitImplCheck checks = TRY((typechecker::TraitImplCheck::make()));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(arg_start),static_cast<size_t>(((((first)->params)).size()))});
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const trait_implementations = ((((*this).get_struct(struct_id))).trait_implementations);
+TRY((((checks).ensure_capacity(((trait_implementations).size())))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((trait_implementations).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> trait_name__trait_id_and_generic_params__ = (_magic_value.value());
 {
-if (TRY((types_match(((*this)),((((((((first)->params))[i])).variable))->type_id),((((((((second)->params))[i])).variable))->type_id))))){
-}
-else {
-return (false);
-}
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt__trait_name__trait_id_and_generic_params__ = trait_name__trait_id_and_generic_params__;
+DeprecatedString const trait_name = ((jakt__trait_name__trait_id_and_generic_params__).template get<0>());
+JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_id_and_generic_params = ((jakt__trait_name__trait_id_and_generic_params__).template get<1>());
 
+TRY((((checks).register_trait(((trait_id_and_generic_params).template get<0>()),trait_name,((((((*this).program))->get_trait(((trait_id_and_generic_params).template get<0>()))))->methods)))));
 }
 
 }
 }
 
-return (true);
-}
-else {
-return (false);
 }
 
+{
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((record).methods)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-return (false);
-}
-
+parser::ParsedMethod method = (_magic_value.value());
+{
+if (((method).is_override)){
+if ((!(((all_virtuals).contains(((((method).parsed_function)).name)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Missing virtual for override"sv),((((method).parsed_function)).name_span)))));
 }
-else {
-return (false);
 }
-
+else if (((all_virtuals).contains(((((method).parsed_function)).name)))){
+TRY((((*this).error(Jakt::DeprecatedString("Missing override keyword on function that is virtual"sv),((((method).parsed_function)).name_span)))));
 }
+TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } ))));
 }
 
-ErrorOr<DeprecatedString> typechecker::Typechecker::type_name(types::TypeId const type_id,bool const debug_mode) const {
-{
-types::TypeId id = type_id;
-if ((((((((*this).program))->get_type(id)))->index() == 30 /* Self */) && ((((*this).self_type_id)).has_value()))){
-(id = (((*this).self_type_id).value()));
-}
-return (TRY((((((*this).program))->type_name(id,debug_mode)))));
 }
 }
 
-ErrorOr<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>>> typechecker::Typechecker::typecheck_match_variant(parser::ParsedMatchCase const case_,types::TypeId const subject_type_id,size_t const variant_index,JaktInternal::Optional<types::TypeId> const final_result_type,types::CheckedEnumVariant const variant,JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const variant_arguments,JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const default_bindings,utility::Span const arguments_span,types::ScopeId const scope_id,types::SafetyMode const safety_mode) {
-{
-JaktInternal::Optional<DeprecatedString> covered_name = JaktInternal::OptionalNone();
-types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,((TRY((((*this).get_scope(scope_id)))))->can_throw),TRY((__jakt_format(Jakt::DeprecatedString("catch-enum-variant({})"sv),((variant).name())))),true))));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>>>>{
-auto&& __jakt_match_variant = variant;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
 {
-(covered_name = name);
-if ((!(((variant_arguments).is_empty())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case '{}' cannot have arguments"sv),name))),arguments_span))));
-}
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
-types::TypeId const& type_id = __jakt_match_value.type_id;
-utility::Span const& span = __jakt_match_value.span;
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(true))));
+ScopeGuard __jakt_var_454([&] {
 {
-(covered_name = name);
-if ((!(((variant_arguments).is_empty())))){
-if ((((variant_arguments).size()) != static_cast<size_t>(1ULL))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case ‘{}’ must have exactly one argument"sv),name))),span))));
-}
-else {
-parser::EnumVariantPatternArgument const variant_argument = ((variant_arguments)[static_cast<i64>(0LL)]);
-types::TypeId const variable_type_id = TRY((((*this).substitute_typevars_in_type(type_id,((*this).generic_inferences)))));
-types::VarId const var_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(((variant_argument).binding),variable_type_id,((variant_argument).is_mutable),span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())))))));
-TRY((((*this).add_var_to_scope(new_scope_id,((variant_argument).binding),var_id,span))));
+((((*this).generic_inferences)).restore(old_generic_inferences));
 }
 
-}
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<types::VarId> const& fields = __jakt_match_value.fields;
-{
-(covered_name = name);
-JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> field_variables = (TRY((DynamicArray<NonnullRefPtr<types::CheckedVariable>>::create_with({}))));
+});
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const trait_implementations = ((((*this).get_struct(struct_id))).trait_implementations);
+TRY((((checks).ensure_capacity(((trait_implementations).size())))));
 {
-JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((trait_implementations).iterator());
 for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::VarId var_id = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> trait_name__trait_id_and_generic_params__ = (_magic_value.value());
 {
-TRY((((field_variables).push(((((*this).program))->get_variable(var_id))))));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt__trait_name__trait_id_and_generic_params__ = trait_name__trait_id_and_generic_params__;
+DeprecatedString const trait_name = ((jakt__trait_name__trait_id_and_generic_params__).template get<0>());
+JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_id_and_generic_params = ((jakt__trait_name__trait_id_and_generic_params__).template get<1>());
+
+JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_id_generic_params_ = trait_id_and_generic_params;
+types::TraitId const trait_id = ((trait_id_generic_params_).template get<0>());
+JaktInternal::DynamicArray<types::TypeId> const generic_params = ((trait_id_generic_params_).template get<1>());
+
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait(trait_id));
+if ((((((trait_)->generic_parameters)).size()) != ((generic_params).size()))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Trait ‘{}’ expects {} generic parameters, but {} were given"sv),trait_name,((((trait_)->generic_parameters)).size()),((generic_params).size())))),((trait_)->name_span)))));
+continue;
+}
+TRY((((*this).specialize_trait(trait_id,generic_params))));
 }
 
 }
 }
 
-JaktInternal::Set<DeprecatedString> seen_names = (TRY((Set<DeprecatedString>::create_with_values({}))));
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(((((*this).get_struct(struct_id))).scope_id)))));
 {
-JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = ((variant_arguments).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
 for (;;){
-JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::EnumVariantPatternArgument arg = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> name__overload_set__ = (_magic_value.value());
 {
-if ((!(((((arg).name)).has_value())))){
-bool found_field_name = false;
-JaktInternal::DynamicArray<DeprecatedString> field_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt__name__overload_set__ = name__overload_set__;
+DeprecatedString const name = ((jakt__name__overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt__name__overload_set__).template get<1>());
+
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<types::CheckedVariable>> _magic = ((field_variables).iterator());
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<types::CheckedVariable> var = (_magic_value.value());
+types::FunctionId function_id = (_magic_value.value());
 {
-TRY((((field_names).push(((var)->name)))));
-if ((((var)->name) == ((arg).binding))){
-(found_field_name = true);
-}
+TRY((((checks).register_method(struct_type_id,name,function_id,((*this))))));
 }
 
 }
 }
 
-if ((!(found_field_name))){
-JaktInternal::DynamicArray<DeprecatedString> unused_field_names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-{
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((field_names).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-DeprecatedString field_name = (_magic_value.value());
-{
-if (((seen_names).contains(field_name))){
-continue;
+
 }
-TRY((((unused_field_names).push(field_name))));
 }
 
 }
+
+TRY((((checks).throw_errors(((((*this).get_struct(struct_id))).name_span),((*this))))));
+(((*this).current_struct_type_id) = JaktInternal::OptionalNone());
+}
+return {};
 }
 
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Match case argument '{}' for struct-like enum variant '{}' cannot be anon"sv),((arg).binding),name))),((arg).span),TRY((__jakt_format(Jakt::DeprecatedString("Available arguments for '{}' are: {}\n"sv),name,utility::join(unused_field_names,Jakt::DeprecatedString(", "sv))))),((arg).span)))));
-continue;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_lambda(JaktInternal::DynamicArray<parser::ParsedCapture> const captures,JaktInternal::DynamicArray<parser::ParsedParameter> const params,bool const can_throw,bool const is_fat_arrow,NonnullRefPtr<typename parser::ParsedType> const return_type,parser::ParsedBlock const block,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode) {
+{
+NonnullRefPtr<typename parser::ParsedType> const synthetic_type = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Function>(params,can_throw,return_type,span)));
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+ScopeGuard __jakt_var_455([&] {
+{
+((((*this).generic_inferences)).restore(old_generic_inferences));
 }
+
+});
+types::TypeId type_id = TRY((((*this).typecheck_typename(synthetic_type,scope_id,JaktInternal::OptionalNone()))));
+JaktInternal::Tuple<types::TypeId,types::FunctionId> return_type_id_pseudo_function_id_ = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Tuple<types::TypeId,types::FunctionId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
+types::FunctionId const& pseudo_function_id = __jakt_match_value.pseudo_function_id;
+return JaktInternal::ExplicitValue((Tuple{return_type_id, pseudo_function_id}));
+};/*case end*/
+default: {
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("Expected the just-checked function to be of a function type"sv)))));
 }
-DeprecatedString const arg_name = ((arg).name).value_or_lazy_evaluated([&] { return ((arg).binding); });
-if (((seen_names).contains(arg_name))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case argument '{}' is already defined"sv),arg_name))),((arg).span)))));
-continue;
+};/*case end*/
+}/*switch end*/
+}()
+));
+types::TypeId return_type_id = ((return_type_id_pseudo_function_id_).template get<0>());
+types::FunctionId pseudo_function_id = ((return_type_id_pseudo_function_id_).template get<1>());
+
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::ScopeId effective_namespace_parent_scope_id = scope_id;
+NonnullRefPtr<types::Scope> effective_namespace_parent_scope = TRY((((*this).get_scope(scope_id))));
+while (((effective_namespace_parent_scope)->is_block_scope)){
+(effective_namespace_parent_scope_id = (((effective_namespace_parent_scope)->parent).value()));
+(effective_namespace_parent_scope = TRY((((*this).get_scope(effective_namespace_parent_scope_id)))));
 }
-TRY((((seen_names).add(arg_name))));
-JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> matched_field_variable = JaktInternal::OptionalNone();
+types::ScopeId lambda_scope_id = TRY((((*this).create_scope(effective_namespace_parent_scope_id,can_throw,Jakt::DeprecatedString("lambda"sv),true))));
+bool is_capturing_everything = false;
+JaktInternal::DynamicArray<types::CheckedCapture> checked_captures = (TRY((DynamicArray<types::CheckedCapture>::create_with({}))));
+bool has_dependent_capture = false;
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<types::CheckedVariable>> _magic = ((field_variables).iterator());
+JaktInternal::ArrayIterator<parser::ParsedCapture> _magic = ((captures).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedCapture> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<types::CheckedVariable> var = (_magic_value.value());
+parser::ParsedCapture capture = (_magic_value.value());
 {
-if ((((var)->name) == arg_name)){
-(matched_field_variable = var);
+if (((capture).index() == 4 /* AllByReference */)){
+TRY((((checked_captures).push( types::CheckedCapture { typename types::CheckedCapture::AllByReference(Jakt::DeprecatedString(""sv),((capture).span())) } ))));
+if ((!(is_capturing_everything))){
+(is_capturing_everything = true);
+(lambda_scope_id = TRY((((*this).create_scope(scope_id,can_throw,Jakt::DeprecatedString("lambda"sv),true)))));
+}
 }
+else if (((TRY((((*this).find_var_in_scope(scope_id,((capture).name())))))).has_value())){
+DeprecatedString const name = ((capture).name());
+utility::Span const span = ((capture).span());
+TRY((((checked_captures).push(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedCapture, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = capture;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( types::CheckedCapture { typename types::CheckedCapture::ByValue(name,span) } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( types::CheckedCapture { typename types::CheckedCapture::ByReference(name,span) } );
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue( types::CheckedCapture { typename types::CheckedCapture::ByMutableReference(name,span) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(({ Optional<types::CheckedCapture> __jakt_var_456; {
+(has_dependent_capture = true);
+if ((!(((*this).in_comptime_function_call)))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Comptime dependency capture ‘{}’ is only allowed in comptime function calls"sv),name))),span))));
 }
+__jakt_var_456 =  types::CheckedCapture { typename types::CheckedCapture::ByComptimeDependency(name,span) } ; goto __jakt_label_413;
 
 }
+__jakt_label_413:; __jakt_var_456.release_value(); }));
+};/*case end*/
+case 4: {
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("AllByReference capture should not be looked up by name"sv)))));
 }
-
-if (((matched_field_variable).has_value())){
-types::TypeId const substituted_type_id = TRY((((*this).substitute_typevars_in_type((((matched_field_variable.value()))->type_id),((*this).generic_inferences)))));
-utility::Span const matched_span = (((matched_field_variable.value()))->definition_span);
-if (((*this).dump_type_hints)){
-TRY((((*this).dump_type_hint((((matched_field_variable.value()))->type_id),((arg).span)))));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+))))));
+if ((!(is_capturing_everything))){
+NonnullRefPtr<types::CheckedVariable> const var = (TRY((((*this).find_var_in_scope(scope_id,((capture).name()))))).value());
+bool const is_this = (((var)->name) == Jakt::DeprecatedString("this"sv));
+types::VarId const var_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(name,((var)->type_id),(((var)->is_mutable) && ((is_this || ((capture).index() == 1 /* ByReference */)) || ((capture).index() == 2 /* ByMutableReference */))),((var)->definition_span),((var)->type_span),((var)->visibility),((var)->owner_scope))))))));
+TRY((((*this).add_var_to_scope(lambda_scope_id,name,var_id,span))));
 }
-types::VarId const var_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(((arg).binding),substituted_type_id,((arg).is_mutable),matched_span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())))))));
-TRY((((*this).add_var_to_scope(new_scope_id,((arg).binding),var_id,matched_span))));
 }
 else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case argument '{}' does not exist in struct-like enum variant '{}'"sv),arg_name,name))),((arg).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Variable '{}' not found"sv),((capture).name())))),span))));
 }
 
 }
@@ -7970,1191 +7640,1338 @@ TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Match case argume
 }
 }
 
+if ((!(is_capturing_everything))){
+types::ScopeId current_scope_id = scope_id;
+NonnullRefPtr<types::Scope> lambda_scope = TRY((((*this).get_scope(lambda_scope_id))));
+while ((!(((current_scope_id).equals(effective_namespace_parent_scope_id))))){
+NonnullRefPtr<types::Scope> const current_scope = TRY((((*this).get_scope(current_scope_id))));
+TRY((((((lambda_scope)->resolution_mixins)).push(current_scope_id))));
+(current_scope_id = (((current_scope)->parent).value()));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& name = __jakt_match_value.name;
-{
-(covered_name = name);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({}))));
+JaktInternal::DynamicArray<types::CheckedParameter> checked_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+bool first = true;
 {
-JaktInternal::DictionaryIterator<DeprecatedString,parser::ParsedPatternDefault> _magic = ((default_bindings).iterator());
+JaktInternal::ArrayIterator<parser::ParsedParameter> _magic = ((params).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> ___default___ = (_magic_value.value());
+parser::ParsedParameter param = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,parser::ParsedPatternDefault> const jakt_____default___ = ___default___;
-DeprecatedString const _ = ((jakt_____default___).template get<0>());
-parser::ParsedPatternDefault const default_ = ((jakt_____default___).template get<1>());
-
-NonnullRefPtr<typename types::CheckedStatement> const checked_var_decl = TRY((((*this).typecheck_var_decl(((default_).variable),((default_).value),new_scope_id,safety_mode,((((default_).variable)).span)))));
-TRY((((defaults).push(checked_var_decl))));
+types::CheckedParameter const checked_param = TRY((((*this).typecheck_parameter(param,scope_id,first,JaktInternal::OptionalNone(),JaktInternal::OptionalNone()))));
+TRY((((checked_params).push(checked_param))));
+types::VarId const var_id = TRY((((module)->add_variable(((checked_param).variable)))));
+TRY((((*this).add_var_to_scope(lambda_scope_id,((((checked_param).variable))->name),var_id,((((checked_param).variable))->definition_span)))));
+(first = false);
 }
 
 }
 }
 
-JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>> const checked_body_result_type_ = TRY((((*this).typecheck_match_body(((case_).body),new_scope_id,safety_mode,((((*this).generic_inferences))),final_result_type,((case_).marker_span)))));
-types::CheckedMatchBody const checked_body = ((checked_body_result_type_).template get<0>());
-JaktInternal::Optional<types::TypeId> const result_type = ((checked_body_result_type_).template get<1>());
+JaktInternal::Optional<types::FunctionId> const previous_function_id = ((*this).current_function_id);
+(((*this).current_function_id) = pseudo_function_id);
+ScopeGuard __jakt_var_457([&] {
+{
+(((*this).current_function_id) = previous_function_id);
+}
 
-types::CheckedMatchCase const checked_match_case =  types::CheckedMatchCase { typename types::CheckedMatchCase::EnumVariant(defaults,((variant).name()),variant_arguments,subject_type_id,variant_index,new_scope_id,checked_body,((case_).marker_span)) } ;
-return ((Tuple{covered_name, checked_match_case, result_type}));
+});
+if (has_dependent_capture){
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::DependentFunction>(checked_captures,checked_params,can_throw,return_type_id,block,span,type_id,pseudo_function_id,lambda_scope_id))));
 }
+types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(block,lambda_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+if (((return_type_id).equals(types::unknown_type_id()))){
+bool return_type_updated = false;
+if (((!(is_fat_arrow)) && ((return_type)->index() == 13 /* Empty */))){
+(return_type_id = types::void_type_id());
+(return_type_updated = true);
 }
-
-ErrorOr<void> typechecker::Typechecker::error_with_hint(DeprecatedString const message,utility::Span const span,DeprecatedString const hint,utility::Span const hint_span) {
+else if ((is_fat_arrow && ((!(((((checked_block).statements)).is_empty()))) && (((((((checked_block).statements)).last()).value()))->index() == 8 /* Return */)))){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const val = (((((((checked_block).statements)).last()).value()))->get<types::CheckedStatement::Return>()).val;
+if (((val).has_value())){
+(return_type_id = TRY((((*this).resolve_type_var((((val.value()))->type()),lambda_scope_id)))));
+(return_type_updated = true);
+}
+}
+if (return_type_updated){
+(type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
+bool const& can_throw = __jakt_match_value.can_throw;
+types::FunctionId const& pseudo_function_id = __jakt_match_value.pseudo_function_id;
+return JaktInternal::ExplicitValue(TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Function>(params,can_throw,return_type_id,pseudo_function_id))))))));
+};/*case end*/
+default: {
 {
-if ((!(((*this).ignore_errors)))){
-TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::MessageWithHint(message,span,hint,hint_span) } ))));
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("Expected the just-checked function to be of a function type"sv)))));
+}
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
-return {};
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Function>(checked_captures,checked_params,can_throw,return_type_id,checked_block,span,type_id,pseudo_function_id,lambda_scope_id))));
+}
 }
 
-ErrorOr<JaktInternal::Optional<typechecker::TraitImplementationDescriptor>> typechecker::Typechecker::find_singular_trait_implementation(types::TypeId const type_id,DeprecatedString const trait_name,types::ScopeId const scope_id,utility::Span const span) {
+NonnullRefPtr<types::CheckedVariable> typechecker::Typechecker::get_variable(types::VarId const id) const {
 {
-JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,trait_name))));
-if ((!(((trait_id).has_value())))){
-return (JaktInternal::OptionalNone());
+return (((((*this).program))->get_variable(id)));
 }
-JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> const trait_impls = TRY((((*this).find_all_implementations_of_trait(type_id,(trait_id.value())))));
-if (((trait_impls).is_empty())){
-return (JaktInternal::OptionalNone());
 }
-if ((((trait_impls).size()) > static_cast<size_t>(1ULL))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("type ‘{}’ implements trait ‘{}’ more than once, but a singular implementation is allowed"sv),TRY((((*this).type_name(type_id,false)))),trait_name))),span))));
+
+ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>>> typechecker::Typechecker::resolve_default_params(JaktInternal::DynamicArray<types::CheckedParameter> const params,JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const args,types::ScopeId const scope_id,types::SafetyMode const safety_mode,size_t const arg_offset,utility::Span const span) {
+{
+size_t params_with_default_value = static_cast<size_t>(0ULL);
+{
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((params).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return (typechecker::TraitImplementationDescriptor((trait_id.value()),trait_name,((trait_impls)[static_cast<i64>(0LL)])));
+types::CheckedParameter param = (_magic_value.value());
+{
+if (((((param).default_value)).has_value())){
+((params_with_default_value++));
 }
 }
 
-ErrorOr<types::TypeId> typechecker::Typechecker::find_or_add_type_id(NonnullRefPtr<typename types::Type> const type) {
-{
-return (TRY((((((*this).program))->find_or_add_type_id(type,((*this).current_module_id))))));
 }
 }
 
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>>> typechecker::Typechecker::find_namespace_in_scope(types::ScopeId const scope_id,DeprecatedString const name,bool const treat_aliases_as_imports) const {
+if (((((args).size()) >= (JaktInternal::checked_sub<size_t>((JaktInternal::checked_sub<size_t>(((params).size()),arg_offset)),params_with_default_value))) && (((args).size()) <= (JaktInternal::checked_sub<size_t>(((params).size()),arg_offset))))){
+size_t consumed_arg = static_cast<size_t>(0ULL);
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>> resolved_args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
 {
-return (TRY((((((*this).program))->find_namespace_in_scope(scope_id,name,treat_aliases_as_imports)))));
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(arg_offset),static_cast<size_t>(((params).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+types::CheckedParameter const param = ((params)[i]);
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> maybe_checked_expr = JaktInternal::OptionalNone();
+if ((!(((param).requires_label)))){
+if ((((args).size()) <= consumed_arg)){
+if ((!(((((param).default_value)).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Missing argument for function parameter {}"sv),((((param).variable))->name)))),span))));
+continue;
 }
+(maybe_checked_expr = ((param).default_value));
 }
+else {
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const name_span_expr_ = ((args)[consumed_arg]);
+DeprecatedString const name = ((name_span_expr_).template get<0>());
+utility::Span const span = ((name_span_expr_).template get<1>());
+NonnullRefPtr<typename parser::ParsedExpression> const expr = ((name_span_expr_).template get<2>());
 
-ErrorOr<void> typechecker::Typechecker::typecheck_enum_predecl(parser::ParsedRecord const parsed_record,types::EnumId const enum_id,types::ScopeId const scope_id) {
-{
-types::TypeId const enum_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id)))))));
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = enum_type_id);
-ScopeGuard __jakt_var_492([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
-types::ScopeId const enum_scope_id = TRY((((*this).create_scope(scope_id,false,TRY((__jakt_format(Jakt::DeprecatedString("enum({})"sv),((parsed_record).name)))),false))));
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(enum_scope_id))));
-(((scope)->namespace_name) = ((parsed_record).name));
-TRY((((*this).add_enum_to_scope(scope_id,((parsed_record).name),enum_id,((parsed_record).name_span)))));
-types::TypeId const underlying_type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((parsed_record).record_type);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::ValueEnum>();NonnullRefPtr<typename parser::ParsedType> const& underlying_type = __jakt_match_value.underlying_type;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_typename(underlying_type,scope_id,JaktInternal::OptionalNone())))));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } ));
-};/*case end*/
-}/*switch end*/
-}()
-));
-bool const is_boxed = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((parsed_record).record_type);
-switch(__jakt_match_variant.index()) {
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::SumEnum>();bool const& is_boxed = __jakt_match_value.is_boxed;
-return JaktInternal::ExplicitValue(is_boxed);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<types::CheckedField> checked_fields = (TRY((DynamicArray<types::CheckedField>::create_with({}))));
-JaktInternal::Set<DeprecatedString> seen_fields = (TRY((Set<DeprecatedString>::create_with_values({}))));
-if (((((parsed_record).record_type)).index() == 3 /* SumEnum */)){
-JaktInternal::DynamicArray<parser::ParsedField> const fields = ((((parsed_record).record_type)).get<parser::RecordType::SumEnum>()).fields;
-{
-JaktInternal::ArrayIterator<parser::ParsedField> _magic = ((fields).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((!(((name).is_empty()))) && (name != ((((param).variable))->name)))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Wrong parameter name in argument label (got '{}', expected '{}')"sv),name,((((param).variable))->name)))),span))));
 }
-parser::ParsedField field = (_magic_value.value());
-{
-parser::ParsedVarDecl const var_decl = ((field).var_decl);
-if (((seen_fields).contains(((var_decl).name)))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Field '{}' is defined more than once"sv),((var_decl).name)))),((var_decl).span)))));
-continue;
+(maybe_checked_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,((((param).variable))->type_id))))));
+((consumed_arg++));
 }
-TRY((((seen_fields).add(((var_decl).name)))));
-types::TypeId const type_id = TRY((((*this).typecheck_typename(((var_decl).parsed_type),enum_scope_id,((var_decl).name)))));
-NonnullRefPtr<types::CheckedVariable> const checked_var = TRY((types::CheckedVariable::__jakt_create(((var_decl).name),type_id,((var_decl).is_mutable),((var_decl).span),((((var_decl).parsed_type))->span()),TRY((((*this).typecheck_visibility(((field).visibility),enum_scope_id)))),JaktInternal::OptionalNone())));
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value = JaktInternal::OptionalNone();
-if (((((field).default_value)).has_value())){
-(default_value = TRY((((*this).typecheck_expression((((field).default_value).value()),enum_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,type_id)))));
+
 }
-if ((((*this).dump_type_hints) && ((((var_decl).parsed_type))->index() == 13 /* Empty */))){
-TRY((((*this).dump_type_hint(type_id,((var_decl).span)))));
+else {
+(maybe_checked_expr = ((param).default_value));
+if ((((args).size()) > consumed_arg)){
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const name_span_expr_ = ((args)[consumed_arg]);
+DeprecatedString const name = ((name_span_expr_).template get<0>());
+utility::Span const span = ((name_span_expr_).template get<1>());
+NonnullRefPtr<typename parser::ParsedExpression> const expr = ((name_span_expr_).template get<2>());
+
+if (TRY((((*this).validate_argument_label(param,name,span,expr,maybe_checked_expr))))){
+(maybe_checked_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,((((param).variable))->type_id))))));
+((consumed_arg++));
+}
+}
+}
+
+if (((maybe_checked_expr).has_value())){
+NonnullRefPtr<typename types::CheckedExpression> checked_arg = (maybe_checked_expr.value());
+TRY((((resolved_args).push((Tuple{((((param).variable))->name), span, checked_arg})))));
 }
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::VarId const variable_id = TRY((((module)->add_variable(checked_var))));
-TRY((((checked_fields).push(types::CheckedField(variable_id,default_value,((field).default_value))))));
 }
 
 }
 }
 
+return (resolved_args);
 }
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-(((((module)->enums))[((enum_id).id)]) = types::CheckedEnum(((parsed_record).name),((parsed_record).name_span),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),(TRY((DynamicArray<types::CheckedEnumVariant>::create_with({})))),checked_fields,enum_scope_id,((parsed_record).definition_linkage),(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))),((parsed_record).record_type),underlying_type_id,enum_type_id,is_boxed));
-JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters = ((((((module)->enums))[((enum_id).id)])).generic_parameters);
-TRY((((generic_parameters).ensure_capacity(((((parsed_record).generic_parameters)).size())))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Wrong number of arguments"sv),span))));
+return ((TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({})))));
+}
+
+}
+}
+
+ErrorOr<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> typechecker::Typechecker::find_all_implementations_of_trait(types::TypeId const type_id,types::TraitId const trait_id) {
 {
-JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((parsed_record).generic_parameters)).iterator());
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>, ErrorOr<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>>>{
+auto&& __jakt_match_variant = *((*this).get_type(type_id));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_458; {
+types::CheckedStruct const struct_ = ((*this).get_struct(struct_id));
+JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> implementations = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((((struct_).trait_implementations)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedGenericParameter gen_parameter = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> ___trait_descriptor__ = (_magic_value.value());
 {
-types::TypeId const parameter_type_id = types::TypeId(((*this).current_module_id),((((((*this).current_module()))->types)).size()));
-types::CheckedGenericParameter checked_param = TRY((types::CheckedGenericParameter::make(parameter_type_id,((gen_parameter).span))));
-JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((gen_parameter).name),trait_implementations)))))));
-if (((((gen_parameter).requires_list)).has_value())){
-TRY((((*this).fill_trait_requirements((((gen_parameter).requires_list).value()),((((checked_param).constraints))),((trait_implementations)),scope_id))));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt_____trait_descriptor__ = ___trait_descriptor__;
+DeprecatedString const _ = ((jakt_____trait_descriptor__).template get<0>());
+JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_descriptor = ((jakt_____trait_descriptor__).template get<1>());
+
+if (((((trait_descriptor).template get<0>())).equals(trait_id))){
+TRY((((implementations).push(((trait_descriptor).template get<1>())))));
 }
-TRY((((generic_parameters).push(checked_param))));
-TRY((((*this).add_type_to_scope(enum_scope_id,((gen_parameter).name),parameter_type_id,((gen_parameter).span)))));
 }
 
 }
 }
 
-if (((((parsed_record).implements_list)).has_value())){
-TRY((((*this).fill_trait_implementation_list((((parsed_record).implements_list).value()),((((((((module)->enums))[((enum_id).id)])).trait_implementations))),enum_scope_id,JaktInternal::OptionalNone()))));
+__jakt_var_458 = implementations; goto __jakt_label_414;
+
 }
-bool const is_extern = ((((parsed_record).definition_linkage)).index() == 1 /* External */);
+__jakt_label_414:; __jakt_var_458.release_value(); }));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_459; {
+types::CheckedStruct const struct_ = ((*this).get_struct(struct_id));
+JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> implementations = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))));
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((parsed_record).methods)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((((struct_).trait_implementations)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMethod method = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> ___trait_descriptor__ = (_magic_value.value());
 {
-parser::ParsedFunction const func = ((method).parsed_function);
-types::ScopeId const method_scope_id = TRY((((*this).create_scope(enum_scope_id,((func).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("method({}::{})"sv),((parsed_record).name),((func).name)))),true))));
-types::ScopeId const block_scope_id = TRY((((*this).create_scope(method_scope_id,((func).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("method-block({}::{})"sv),((parsed_record).name),((func).name)))),true))));
-bool const is_generic = ((!(((((parsed_record).generic_parameters)).is_empty()))) || (!(((((func).generic_parameters)).is_empty()))));
-NonnullRefPtr<types::CheckedFunction> checked_function = TRY((types::CheckedFunction::__jakt_create(((func).name),((func).name_span),TRY((((*this).typecheck_visibility(((method).visibility),enum_scope_id)))),types::unknown_type_id(),JaktInternal::OptionalNone(),(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),TRY((types::FunctionGenerics::__jakt_create(method_scope_id,(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false),((func).can_throw),((func).type),((func).linkage),method_scope_id,JaktInternal::OptionalNone(),((!(is_generic)) || is_extern),func,((func).is_comptime),false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
-types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
-JaktInternal::DynamicArray<types::FunctionGenericParameter> generic_parameters = (TRY((DynamicArray<types::FunctionGenericParameter>::create_with({}))));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt_____trait_descriptor__ = ___trait_descriptor__;
+DeprecatedString const _ = ((jakt_____trait_descriptor__).template get<0>());
+JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_descriptor = ((jakt_____trait_descriptor__).template get<1>());
+
+if (((((trait_descriptor).template get<0>())).equals(trait_id))){
+TRY((((implementations).push(((trait_descriptor).template get<1>())))));
+}
+}
+
+}
+}
+
+__jakt_var_459 = implementations; goto __jakt_label_415;
+
+}
+__jakt_label_415:; __jakt_var_459.release_value(); }));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_460; {
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> implementations = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))));
 {
-JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((func).generic_parameters)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((((enum_).trait_implementations)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedGenericParameter generic_parameter = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> ___trait_descriptor__ = (_magic_value.value());
 {
-types::TypeId const type_var_type_id = types::TypeId(((*this).current_module_id),((((((*this).current_module()))->types)).size()));
-types::FunctionGenericParameter parameter = TRY((types::FunctionGenericParameter::parameter(type_var_type_id,((generic_parameter).span))));
-JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((generic_parameter).name),trait_implementations)))))));
-if (((((generic_parameter).requires_list)).has_value())){
-TRY((((*this).fill_trait_requirements((((generic_parameter).requires_list).value()),((((((parameter).checked_parameter)).constraints))),((trait_implementations)),scope_id))));
-}
-TRY((((generic_parameters).push(parameter))));
-if ((!(((func).must_instantiate)))){
-TRY((((*this).add_type_to_scope(method_scope_id,((generic_parameter).name),type_var_type_id,((generic_parameter).span)))));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt_____trait_descriptor__ = ___trait_descriptor__;
+DeprecatedString const _ = ((jakt_____trait_descriptor__).template get<0>());
+JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_descriptor = ((jakt_____trait_descriptor__).template get<1>());
+
+if (((((trait_descriptor).template get<0>())).equals(trait_id))){
+TRY((((implementations).push(((trait_descriptor).template get<1>())))));
 }
 }
 
 }
 }
 
-(((((checked_function)->generics))->params) = generic_parameters);
+__jakt_var_460 = implementations; goto __jakt_label_416;
+
+}
+__jakt_label_416:; __jakt_var_460.release_value(); }));
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_461; {
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> implementations = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))));
 {
-JaktInternal::ArrayIterator<parser::ParsedParameter> _magic = ((((func).params)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((((enum_).trait_implementations)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedParameter param = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> ___trait_descriptor__ = (_magic_value.value());
 {
-if ((((((param).variable)).name) == Jakt::DeprecatedString("this"sv))){
-NonnullRefPtr<types::CheckedVariable> const checked_variable = TRY((types::CheckedVariable::__jakt_create(((((param).variable)).name),enum_type_id,((((param).variable)).is_mutable),((((param).variable)).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
-TRY((((checked_function)->add_param(types::CheckedParameter(((param).requires_label),checked_variable,JaktInternal::OptionalNone())))));
-}
-else {
-types::TypeId const param_type = TRY((((*this).typecheck_typename(((((param).variable)).parsed_type),method_scope_id,((((param).variable)).name)))));
-NonnullRefPtr<types::CheckedVariable> const checked_variable = TRY((types::CheckedVariable::__jakt_create(((((param).variable)).name),param_type,((((param).variable)).is_mutable),((((param).variable)).span),((((((param).variable)).parsed_type))->span()), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value = JaktInternal::OptionalNone();
-if (((((param).default_argument)).has_value())){
-types::TypeId const param_type = TRY((((*this).typecheck_typename(((((param).variable)).parsed_type),method_scope_id,((((param).variable)).name)))));
-(default_value = TRY((((*this).typecheck_expression((((param).default_argument).value()),scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,param_type)))));
+JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt_____trait_descriptor__ = ___trait_descriptor__;
+DeprecatedString const _ = ((jakt_____trait_descriptor__).template get<0>());
+JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_descriptor = ((jakt_____trait_descriptor__).template get<1>());
+
+if (((((trait_descriptor).template get<0>())).equals(trait_id))){
+TRY((((implementations).push(((trait_descriptor).template get<1>())))));
 }
-TRY((((checked_function)->add_param(types::CheckedParameter(((param).requires_label),checked_variable,default_value)))));
 }
 
+}
 }
 
+__jakt_var_461 = implementations; goto __jakt_label_417;
+
 }
+__jakt_label_417:; __jakt_var_461.release_value(); }));
+};/*case end*/
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
+types::TraitId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_462; {
+if (((id).equals(trait_id))){
+return ((TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({(TRY((DynamicArray<types::TypeId>::create_with({}))))})))));
 }
+__jakt_var_462 = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({})))); goto __jakt_label_418;
 
-TRY((((*this).add_function_to_scope(enum_scope_id,((func).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((parsed_record).name_span)))));
-types::TypeId const function_return_type_id = TRY((((*this).typecheck_typename(((func).return_type),method_scope_id,JaktInternal::OptionalNone()))));
-(((checked_function)->return_type_id) = function_return_type_id);
 }
+__jakt_label_418:; __jakt_var_462.release_value(); }));
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> __jakt_var_463; {
+if ((!(((id).equals(trait_id))))){
+return ((TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({})))));
+}
+__jakt_var_463 = (TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({args})))); goto __jakt_label_419;
 
+}
+__jakt_label_419:; __jakt_var_463.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue((TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({})))));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>>> typechecker::Typechecker::find_namespace_in_scope(types::ScopeId const scope_id,DeprecatedString const name,bool const treat_aliases_as_imports) const {
+{
+return (TRY((((((*this).program))->find_namespace_in_scope(scope_id,name,treat_aliases_as_imports)))));
 }
-return {};
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::dereference_if_needed(NonnullRefPtr<typename types::CheckedExpression> const checked_expr,utility::Span const span) {
+ErrorOr<void> typechecker::Typechecker::typecheck_struct_fields(parser::ParsedRecord const record,types::StructId const struct_id) {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(((checked_expr)->type())));
+types::CheckedStruct structure = ((*this).get_struct(struct_id));
+types::ScopeId const checked_struct_scope_id = ((((*this).get_struct(struct_id))).scope_id);
+types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
+(((*this).current_struct_type_id) = struct_type_id);
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = struct_type_id);
+ScopeGuard __jakt_var_464([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+JaktInternal::DynamicArray<parser::ParsedField> const parsed_fields = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<parser::ParsedField>, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((record).record_type);
 switch(__jakt_match_variant.index()) {
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Dereference() } ,span,type_id))));
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Struct>();JaktInternal::DynamicArray<parser::ParsedField> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(fields);
 };/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Dereference() } ,span,type_id))));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Class>();JaktInternal::DynamicArray<parser::ParsedField> const& fields = __jakt_match_value.fields;
+return JaktInternal::ExplicitValue(fields);
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(checked_expr);
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_struct_fields cannot handle non-structs"sv)))));
+}
 };/*case end*/
 }/*switch end*/
 }()
-)));
-}
-}
-
-DeprecatedString typechecker::Typechecker::get_argument_name(JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const arg) const {
+));
 {
-if ((!(((((arg).template get<0>())).is_empty())))){
-return (((arg).template get<0>()));
+JaktInternal::ArrayIterator<parser::ParsedField> _magic = ((parsed_fields).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, DeprecatedString>{
-auto&& __jakt_match_variant = *((arg).template get<2>());
-switch(__jakt_match_variant.index()) {
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();DeprecatedString const& name = __jakt_match_value.name;
+parser::ParsedField unchecked_member = (_magic_value.value());
 {
-return (name);
+parser::ParsedVarDecl const parsed_var_decl = ((unchecked_member).var_decl);
+types::TypeId const checked_member_type = TRY((((*this).typecheck_typename(((parsed_var_decl).parsed_type),checked_struct_scope_id,((parsed_var_decl).name)))));
+TRY((((*this).check_that_type_doesnt_contain_reference(checked_member_type,((((parsed_var_decl).parsed_type))->span())))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::VarId const variable_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(((parsed_var_decl).name),checked_member_type,((parsed_var_decl).is_mutable),((parsed_var_decl).span),JaktInternal::OptionalNone(),TRY((((*this).typecheck_visibility(((unchecked_member).visibility),checked_struct_scope_id)))),JaktInternal::OptionalNone())))))));
+TRY((((((structure).fields)).push(types::CheckedField(variable_id,JaktInternal::OptionalNone(),((unchecked_member).default_value))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-parser::UnaryOperator const& op = __jakt_match_value.op;
-{
-if (((((op).index() == 7 /* Reference */) || ((op).index() == 8 /* MutableReference */)) || ((op).index() == 5 /* Dereference */))){
-if (((expr)->index() == 9 /* Var */)){
-DeprecatedString const name = ((expr)->get<parser::ParsedExpression::Var>()).name;
-return (name);
+
 }
 }
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+return {};
+}
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_call(parser::ParsedCall const call,types::ScopeId const caller_scope_id,utility::Span const span,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const this_expr,JaktInternal::Optional<types::StructLikeId> const parent_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> type_hint,bool const must_be_enum_constructor) {
+{
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
+types::TypeId return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } );
+JaktInternal::DynamicArray<types::TypeId> generic_arguments = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+bool callee_throws = false;
+JaktInternal::DynamicArray<types::ResolvedNamespace> resolved_namespaces = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
+JaktInternal::DynamicArray<types::FunctionId> resolved_function_id_candidates = (TRY((DynamicArray<types::FunctionId>::create_with({}))));
+JaktInternal::Optional<types::FunctionId> resolved_function_id = JaktInternal::OptionalNone();
+JaktInternal::Optional<types::TypeId> maybe_this_type_id = JaktInternal::OptionalNone();
+JaktInternal::Optional<types::FunctionId> generic_checked_function_to_instantiate = JaktInternal::OptionalNone();
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+ScopeGuard __jakt_var_465([&] {
 {
+((((*this).generic_inferences)).restore(old_generic_inferences));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-return (Jakt::DeprecatedString(""sv));
+
+});
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((((call).namespace_)).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+DeprecatedString name = (_magic_value.value());
+{
+TRY((((resolved_namespaces).push(types::ResolvedNamespace(name,JaktInternal::OptionalNone(),JaktInternal::OptionalNone())))));
 }
 
-types::ScopeId typechecker::Typechecker::root_scope_id() const {
-{
-return (types::ScopeId(types::ModuleId(static_cast<size_t>(1ULL)),static_cast<size_t>(0ULL)));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_unary_operation(NonnullRefPtr<typename types::CheckedExpression> const checked_expr,types::CheckedUnaryOperator const checked_op,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode) {
-{
-types::TypeId const expr_type_id = ((checked_expr)->type());
-NonnullRefPtr<typename types::Type> const expr_type = ((*this).get_type(expr_type_id));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = checked_op;
+types::ScopeId callee_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = (((parent_id).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = (parent_id.value());
 switch(__jakt_match_variant.index()) {
 case 0: {
-{
-if (((*this).is_integer(expr_type_id))){
-if ((!(((checked_expr)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of immutable variable"sv),span))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_466; {
+types::CheckedStruct struct_ = ((*this).get_struct(id));
+types::ScopeId scope_id = ((struct_).scope_id);
+while (((resolved_function_id_candidates).is_empty())){
+bool const old_ignore_errors = ((*this).ignore_errors);
+(((*this).ignore_errors) = true);
+(resolved_function_id_candidates = TRY((((*this).resolve_call(call,resolved_namespaces,span,scope_id,must_be_enum_constructor)))));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
+if ((!(((resolved_function_id_candidates).is_empty())))){
+break;
 }
+if (((((struct_).super_struct_id)).has_value())){
+types::StructId const parent_struct_id = (((struct_).super_struct_id).value());
+(struct_ = ((*this).get_struct(parent_struct_id)));
+(scope_id = ((struct_).scope_id));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of non-numeric value"sv),span))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Could not find ‘{}’"sv),((call).name)))),span))));
+break;
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_var_466 = scope_id; goto __jakt_label_420;
+
+}
+__jakt_label_420:; __jakt_var_466.release_value(); }));
 };/*case end*/
 case 1: {
-{
-if (((*this).is_integer(expr_type_id))){
-if ((!(((checked_expr)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of immutable variable"sv),span))));
-}
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of non-numeric value"sv),span))));
-}
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_467; {
+types::ScopeId const scope_id = ((((*this).get_enum(id))).scope_id);
+(resolved_function_id_candidates = TRY((((*this).resolve_call(call,resolved_namespaces,span,scope_id,must_be_enum_constructor)))));
+__jakt_var_467 = scope_id; goto __jakt_label_421;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_421:; __jakt_var_467.release_value(); }));
 };/*case end*/
 case 2: {
-{
-if (((*this).is_integer(expr_type_id))){
-if ((!(((checked_expr)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of immutable variable"sv),span))));
-}
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of non-numeric value"sv),span))));
-}
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Trait>();
+types::TraitId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_468; {
+types::ScopeId const scope_id = ((((*this).get_trait(id)))->scope_id);
+(resolved_function_id_candidates = TRY((((*this).resolve_call(call,resolved_namespaces,span,scope_id,must_be_enum_constructor)))));
+__jakt_var_468 = scope_id; goto __jakt_label_422;
 
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_422:; __jakt_var_468.release_value(); }));
 };/*case end*/
-case 3: {
-{
-if (((*this).is_integer(expr_type_id))){
-if ((!(((checked_expr)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of immutable variable"sv),span))));
-}
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Increment/decrement of non-numeric value"sv),span))));
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 9: {
+return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_469; {
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = (((call).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
 {
-if ((!(TRY((((*this).check_types_for_compat(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ),((checked_expr)->type()),((((*this).generic_inferences))),span))))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot use a logical Not on a value of non-boolean type"sv),span))));
-}
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,expr_type_id))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 10: {
-{
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,expr_type_id))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedUnaryOperator::TypeCast>();
-types::CheckedTypeCast const& cast = __jakt_match_value.value;
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
 {
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,((cast).type_id())))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 4: {
-{
-return (TRY((((*this).typecheck_unary_negate(checked_expr,span,expr_type_id)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 12: {
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
 {
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 13: {
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
 {
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 14: {
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
 {
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 6: {
+}
+else {
 {
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::RawPtr>(expr_type_id)))))))))));
+(resolved_function_id_candidates = TRY((((*this).resolve_call(call,resolved_namespaces,span,caller_scope_id,must_be_enum_constructor)))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 7: {
-{
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Reference>(expr_type_id)))))))))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 8: {
-{
-if ((!(((checked_expr)->is_mutable(((*this).program)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot make mutable reference to immutable value"sv),span))));
+}()))
+;
+__jakt_var_469 = caller_scope_id; goto __jakt_label_423;
+
 }
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::MutableReference>(expr_type_id)))))))))));
+__jakt_label_423:; __jakt_var_469.release_value(); }));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 5: {
+}()))
+;
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> generic_inferences_from_parent = (TRY((Dictionary<DeprecatedString, DeprecatedString>::create_with_entries({}))));
+if ((((parent_id).has_value()) && (((((parent_id.value())).generic_arguments())).has_value()))){
+JaktInternal::DynamicArray<types::TypeId> const arguments = ((((parent_id.value())).generic_arguments()).value());
+JaktInternal::DynamicArray<types::TypeId> const parameters = TRY(((((parent_id.value())).generic_parameters(((((*this).program)))))));
 {
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *expr_type;
-switch(__jakt_match_variant.index()) {
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
-types::TypeId const& type_id = __jakt_match_value.value;
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((arguments).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
 {
-if (((safety_mode).index() == 0 /* Safe */)){
-TRY((((*this).error(Jakt::DeprecatedString("Dereference of raw pointer outside of unsafe block"sv),span))));
+TRY((((generic_inferences_from_parent).set(TRY((((((parameters)[i])).to_string()))),TRY((((((arguments)[i])).to_string())))))));
+TRY((((((*this).generic_inferences)).set(TRY((((((parameters)[i])).to_string()))),TRY((((((arguments)[i])).to_string())))))));
 }
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,type_id))));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
-types::TypeId const& type_id = __jakt_match_value.value;
-{
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,type_id))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
-types::TypeId const& type_id = __jakt_match_value.value;
-{
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,type_id))));
+
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = (((call).name));
+if (__jakt_enum_value == Jakt::DeprecatedString("print"sv)) {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Dereference of a non-pointer type ‘{}’"sv),TRY((((*this).type_name(expr_type_id,false))))))),span))));
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
+{
+NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+TRY((((args).push((Tuple{((call).name), checked_arg})))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(checked_expr,checked_op,span,expr_type_id))));
+
 }
 }
 
-ErrorOr<types::TypeId> typechecker::Typechecker::final_type_resolution_form(types::TypeId const type_id,types::ScopeId const scope_id) const {
-{
-types::TypeId const mapped_type_id = TRY((((*this).resolve_type_var(type_id,scope_id))));
-if ((((((*this).get_type(mapped_type_id)))->index() == 30 /* Self */) && ((((*this).self_type_id)).has_value()))){
-return ((((*this).self_type_id).value()));
+if ((((call).name) == Jakt::DeprecatedString("format"sv))){
+(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+(callee_throws = true);
 }
-return (mapped_type_id);
 }
+return JaktInternal::ExplicitValue<void>();
 }
-
-ErrorOr<void> typechecker::Typechecker::typecheck_namespace_declarations(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
+else if (__jakt_enum_value == Jakt::DeprecatedString("println"sv)) {
 {
-JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
 {
-parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
-types::ScopeId const child_namespace_scope_id = ((children)[i]);
-TRY((((*this).typecheck_namespace_declarations(child_namespace,child_namespace_scope_id))));
+NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+TRY((((args).push((Tuple{((call).name), checked_arg})))));
 }
 
 }
 }
 
+if ((((call).name) == Jakt::DeprecatedString("format"sv))){
+(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+(callee_throws = true);
+}
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprintln"sv)) {
 {
-JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedRecord record = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((record).record_type);
-switch(__jakt_match_variant.index()) {
-case 0: {
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
 {
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
-if ((!(((struct_id).has_value())))){
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find struct that has been previous added"sv)))));
-}
-TRY((((*this).typecheck_struct(record,(struct_id.value()),scope_id))));
+NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+TRY((((args).push((Tuple{((call).name), checked_arg})))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 1: {
-{
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
-if ((!(((struct_id).has_value())))){
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find struct that has been previous added"sv)))));
+
 }
-TRY((((*this).typecheck_struct(record,(struct_id.value()),scope_id))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 3: {
-{
-JaktInternal::Optional<types::EnumId> const enum_id = TRY((((((*this).program))->find_enum_in_scope(scope_id,((record).name)))));
-if ((!(((enum_id).has_value())))){
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find enum that has been previous added"sv)))));
+
+if ((((call).name) == Jakt::DeprecatedString("format"sv))){
+(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+(callee_throws = true);
 }
-TRY((((*this).typecheck_enum(record,(enum_id.value()),scope_id))));
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-{
-JaktInternal::Optional<types::EnumId> const enum_id = TRY((((((*this).program))->find_enum_in_scope(scope_id,((record).name)))));
-if ((!(((enum_id).has_value())))){
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find enum that has been previous added"sv)))));
-}
-TRY((((*this).typecheck_enum(record,(enum_id.value()),scope_id))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+else if (__jakt_enum_value == Jakt::DeprecatedString("eprint"sv)) {
 {
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
+{
+NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+TRY((((args).push((Tuple{((call).name), checked_arg})))));
 }
 
 }
 }
 
+if ((((call).name) == Jakt::DeprecatedString("format"sv))){
+(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+(callee_throws = true);
+}
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("format"sv)) {
 {
-JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((parsed_namespace).functions)).iterator());
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedFunction fun = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
 {
-TRY((((*this).typecheck_function(fun,scope_id))));
+NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+TRY((((args).push((Tuple{((call).name), checked_arg})))));
 }
 
 }
 }
 
+if ((((call).name) == Jakt::DeprecatedString("format"sv))){
+(return_type = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+(callee_throws = true);
+}
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else {
 {
-JaktInternal::ArrayIterator<parser::ParsedExternalTraitImplementation> _magic = ((((parsed_namespace).external_trait_implementations)).iterator());
+i64 max_found_specificity = (-(static_cast<i64>(1LL)));
+JaktInternal::DynamicArray<error::JaktError> errors_while_trying_to_find_matching_function = (TRY((DynamicArray<error::JaktError>::create_with({}))));
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> generic_inferences_for_best_match = (TRY((Dictionary<DeprecatedString, DeprecatedString>::create_with_entries({}))));
+{
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((resolved_function_id_candidates).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedExternalTraitImplementation> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedExternalTraitImplementation implementation = (_magic_value.value());
+types::FunctionId candidate = (_magic_value.value());
 {
-types::TypeId const for_type = TRY((((*this).typecheck_typename(((implementation).for_type),scope_id,JaktInternal::OptionalNone()))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((*this).get_type(for_type));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = TRY((((*this).match_function_and_resolve_args(call,caller_scope_id,candidate,safety_mode,span,this_expr))));
 switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typechecker::FunctionMatchResult::MatchSuccess>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& resolved_args = __jakt_match_value.args;
+JaktInternal::Optional<types::TypeId> const& resolved_this_type_id = __jakt_match_value.maybe_this_type_id;
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const& used_generic_inferences = __jakt_match_value.used_generic_inferences;
+i64 const& specificity = __jakt_match_value.specificity;
 {
-types::CheckedStruct struct_ = ((*this).get_struct(struct_id));
+if ((specificity > max_found_specificity)){
+(resolved_function_id = candidate);
+(maybe_this_type_id = resolved_this_type_id);
+(max_found_specificity = specificity);
+(generic_inferences_for_best_match = used_generic_inferences);
+(args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({})))));
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((resolved_args).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMethod method = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedExpression> resolved_arg = (_magic_value.value());
 {
-if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
-TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } ))));
-}
-else {
-TRY((((*this).typecheck_function(((method).parsed_function),((struct_).scope_id)))));
-}
-
+TRY((((args).push((Tuple{((call).name), resolved_arg})))));
 }
 
 }
 }
 
+}
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typechecker::FunctionMatchResult::MatchError>();JaktInternal::DynamicArray<error::JaktError> const& errors = __jakt_match_value.errors;
 {
-types::CheckedStruct struct_ = ((*this).get_struct(struct_id));
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
+JaktInternal::ArrayIterator<error::JaktError> _magic = ((errors).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+JaktInternal::Optional<error::JaktError> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMethod method = (_magic_value.value());
+error::JaktError error = (_magic_value.value());
 {
-if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
-TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } ))));
-}
-else {
-TRY((((*this).typecheck_function(((method).parsed_function),((struct_).scope_id)))));
-}
-
+TRY((((errors_while_trying_to_find_matching_function).push(error))));
 }
 
 }
 }
 
+return JaktInternal::LoopContinue{};
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-{
-types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
-{
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+}
+
+}
+}
+
+if ((!(((resolved_function_id).has_value())))){
+if ((!(((resolved_function_id_candidates).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("No function with matching signature found."sv),span))));
+{
+JaktInternal::ArrayIterator<error::JaktError> _magic = ((errors_while_trying_to_find_matching_function).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+JaktInternal::Optional<error::JaktError> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMethod method = (_magic_value.value());
+error::JaktError match_error = (_magic_value.value());
 {
-if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
-TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),enum_id) } ))));
+TRY((((((((*this).compiler))->errors)).push(match_error))));
+}
+
 }
-else {
-TRY((((*this).typecheck_function(((method).parsed_function),((enum_).scope_id)))));
 }
 
+}
+JaktInternal::DynamicArray<types::TypeId> checked_type_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((call).type_args)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename parser::ParsedType> type_arg = (_magic_value.value());
+{
+TRY((((checked_type_args).push(TRY((((*this).typecheck_typename(type_arg,caller_scope_id,JaktInternal::OptionalNone()))))))));
 }
 
 }
 }
 
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
 {
-types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
+NonnullRefPtr<typename types::CheckedExpression> const checked_arg = TRY((((*this).typecheck_expression(((arg).template get<2>()),caller_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+TRY((((args).push((Tuple{((call).name), checked_arg})))));
+}
+
+}
+}
+
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Call>(types::CheckedCall(resolved_namespaces,((call).name),args,checked_type_args,JaktInternal::OptionalNone(),types::builtin( types::BuiltinType { typename types::BuiltinType::Unknown() } ),callee_throws,JaktInternal::OptionalNone()),span,types::builtin( types::BuiltinType { typename types::BuiltinType::Unknown() } )))));
+}
+((((*this).generic_inferences)).restore(generic_inferences_for_best_match));
+TRY((((((*this).generic_inferences)).set_from(generic_inferences_from_parent))));
+NonnullRefPtr<types::CheckedFunction> const callee = ((*this).get_function((resolved_function_id.value())));
+(callee_throws = ((callee)->can_throw));
+(return_type = ((callee)->return_type_id));
+if ((((type_hint).has_value()) && (!(((((type_hint).value())).equals(types::unknown_type_id())))))){
+bool const old_ignore_errors = ((*this).ignore_errors);
+(((*this).ignore_errors) = true);
+TRY((((*this).check_types_for_compat(return_type,(type_hint.value()),((((*this).generic_inferences))),span))));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
+}
+(return_type = TRY((((*this).substitute_typevars_in_type(return_type,((*this).generic_inferences))))));
+if ((((type_hint).has_value()) && (!(((((type_hint).value())).equals(types::unknown_type_id())))))){
+bool const old_ignore_errors = ((*this).ignore_errors);
+if (((callee)->is_instantiated)){
+(((*this).ignore_errors) = true);
+}
+TRY((((*this).check_types_for_compat((type_hint.value()),return_type,((((*this).generic_inferences))),span))));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
+}
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
+JaktInternal::ArrayIterator<types::FunctionGenericParameter> _magic = ((((((callee)->generics))->params)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMethod method = (_magic_value.value());
+types::FunctionGenericParameter generic_typevar = (_magic_value.value());
 {
-if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
-TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),enum_id) } ))));
+if (((((generic_typevar).kind)).index() == 1 /* Parameter */)){
+JaktInternal::Optional<DeprecatedString> const substitution = ((((*this).generic_inferences)).get(TRY((((((generic_typevar).type_id())).to_string())))));
+if (((substitution).has_value())){
+TRY((((generic_arguments).push(TRY((types::TypeId::from_string((substitution.value()))))))));
+}
+else if ((!(((*this).in_comptime_function_call)))){
+TRY((((*this).error(Jakt::DeprecatedString("Not all generic parameters have known types"sv),span))));
 }
 else {
-TRY((((*this).typecheck_function(((method).parsed_function),((enum_).scope_id)))));
+TRY((((generic_arguments).push(((generic_typevar).type_id())))));
 }
 
+}
 }
 
 }
 }
 
+if (((!(((callee)->is_instantiated))) || ((!(((((callee)->linkage)).index() == 1 /* External */))) && (!(((((callee)->generics))->is_specialized_for_types(generic_arguments))))))){
+(generic_checked_function_to_instantiate = static_cast<JaktInternal::Optional<types::FunctionId>>((resolved_function_id.value())));
+}
+else if (((callee)->is_instantiated)){
+if ((((type_hint).has_value()) && (!(((((type_hint).value())).equals(types::unknown_type_id())))))){
+TRY((((*this).check_types_for_compat((type_hint.value()),return_type,((((*this).generic_inferences))),span))));
+}
+}
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
 }
 return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+}()))
+;
+(return_type = TRY((((*this).substitute_typevars_in_type(return_type,((*this).generic_inferences))))));
+if ((callee_throws && (!(((TRY((((*this).get_scope(caller_scope_id)))))->can_throw))))){
+TRY((((*this).error(Jakt::DeprecatedString("Call to function that may throw needs to be in a try statement or a function marked as throws"sv),span))));
 }
-
+if (((generic_checked_function_to_instantiate).has_value())){
+if (((maybe_this_type_id).has_value())){
+(maybe_this_type_id = TRY((((*this).substitute_typevars_in_type((maybe_this_type_id.value()),((*this).generic_inferences))))));
 }
+(resolved_function_id = TRY((((*this).typecheck_and_specialize_generic_function((generic_checked_function_to_instantiate.value()),generic_arguments,callee_scope_id,maybe_this_type_id,((*this).generic_inferences),((call).type_args),span,args)))));
 }
-
+if ((((*this).dump_try_hints) && callee_throws)){
+TRY((((*this).dump_try_hint(span))));
 }
-return {};
+JaktInternal::Optional<DeprecatedString> const external_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<DeprecatedString>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = (((resolved_function_id).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<DeprecatedString>> __jakt_var_470; {
+NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function((resolved_function_id.value())));
+if (((((function)->deprecated_message)).has_value())){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Call to deprecated function: {}"sv),(((function)->deprecated_message).value())))),span))));
 }
+__jakt_var_470 = ((function)->external_name); goto __jakt_label_424;
 
-ErrorOr<JaktInternal::Optional<typechecker::TraitImplementationDescriptor>> typechecker::Typechecker::find_any_singular_trait_implementation(types::TypeId const type_id,JaktInternal::DynamicArray<DeprecatedString> const trait_names,types::ScopeId const scope_id,utility::Span const span) {
-{
+}
+__jakt_label_424:; __jakt_var_470.release_value(); }));
+}
+else {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+}
+}()))
+;
+if (((resolved_function_id).has_value())){
+NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function((resolved_function_id.value())));
+if (((((function)->stores_arguments)).has_value())){
+JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> const argument_behaviour = (((function)->stores_arguments).value());
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((trait_names).iterator());
+JaktInternal::ArrayIterator<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> _magic = ((argument_behaviour).iterator());
 for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString trait_name = (_magic_value.value());
+JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel> index__level__ = (_magic_value.value());
 {
-JaktInternal::Optional<typechecker::TraitImplementationDescriptor> const maybe_impl = TRY((((*this).find_singular_trait_implementation(type_id,trait_name,scope_id,span))));
-if (((maybe_impl).has_value())){
-return (maybe_impl);
+JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel> const jakt__index__level__ = index__level__;
+size_t const index = ((jakt__index__level__).template get<0>());
+parser::ArgumentStoreLevel const level = ((jakt__index__level__).template get<1>());
+
+Function<NonnullRefPtr<typename types::CheckedExpression>(size_t)> const resolve_arg = [&args, &this_expr, &function](size_t index) -> NonnullRefPtr<typename types::CheckedExpression> {
+{
+if (((function)->is_static())){
+return (((((args)[index])).template get<1>()));
+}
+if ((index == static_cast<size_t>(0ULL))){
+return ((this_expr.value()));
 }
+return (((((args)[(JaktInternal::checked_sub<size_t>(index,static_cast<size_t>(1ULL)))])).template get<1>()));
 }
-
+}
+;
+JaktInternal::Optional<types::ScopeId> const arg_scope_id = TRY((((*this).required_scope_id_in_hierarchy_for(resolve_arg(index),caller_scope_id))));
+JaktInternal::Optional<types::ScopeId> const stored_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = level;
+switch(__jakt_match_variant.index()) {
+case 1: {
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::ScopeId>>(((*this).root_scope_id())));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ArgumentStoreLevel::InObject>();size_t const& argument_index = __jakt_match_value.argument_index;
+return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(resolve_arg(argument_index),caller_scope_id)))));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+if (TRY((((*this).scope_lifetime_subsumes(stored_scope_id,arg_scope_id))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot pass this argument by reference, it is not guaranteed to outlive the object it will be stored in"sv),((resolve_arg(index))->span())))));
 }
 }
 
-return (JaktInternal::OptionalNone());
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_defer(NonnullRefPtr<typename parser::ParsedStatement> const statement,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+}
+}
+types::CheckedCall const function_call = types::CheckedCall(resolved_namespaces,((call).name),args,generic_arguments,resolved_function_id,return_type,callee_throws,external_name);
+NonnullRefPtr<typename types::CheckedExpression> const checked_call = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Call>(function_call,span,return_type)));
+bool const in_comptime_function = (((((*this).current_function_id)).has_value()) && ((((*this).get_function(((((*this).current_function_id)).value()))))->is_comptime));
+if (((!(in_comptime_function)) && (((resolved_function_id).has_value()) && ((((*this).get_function((resolved_function_id.value()))))->is_comptime)))){
+NonnullRefPtr<types::CheckedFunction> const resolved_function = ((*this).get_function((resolved_function_id.value())));
+NonnullRefPtr<interpreter::Interpreter> interpreter = TRY((((*this).interpreter())));
+NonnullRefPtr<types::CheckedFunction> const function = ((((*this).program))->get_function(generic_checked_function_to_instantiate.value_or_lazy_evaluated([&] { return (resolved_function_id.value()); })));
+JaktInternal::DynamicArray<types::Value> call_args = (TRY((DynamicArray<types::Value>::create_with({}))));
+JaktInternal::Optional<types::Value> this_argument = JaktInternal::OptionalNone();
+NonnullRefPtr<interpreter::InterpreterScope> eval_scope = TRY((interpreter::InterpreterScope::from_runtime_scope(caller_scope_id,((*this).program),JaktInternal::OptionalNone())));
 {
-bool const was_inside_defer = ((*this).inside_defer);
-(((*this).inside_defer) = true);
-ScopeGuard __jakt_var_493([&] {
-(((*this).inside_defer) = was_inside_defer);
-});
-NonnullRefPtr<typename types::CheckedStatement> const checked_statement = TRY((((*this).typecheck_statement(statement,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-if (((checked_statement)->index() == 5 /* Block */)){
-types::CheckedBlock const block = ((checked_statement)->get<types::CheckedStatement::Block>()).block;
-if (((((block).yielded_type)).has_value())){
-TRY((((*this).error(Jakt::DeprecatedString("‘yield’ inside ‘defer’ is meaningless"sv),span))));
+JaktInternal::DictionaryIterator<DeprecatedString,DeprecatedString> _magic = ((((((*this).generic_inferences)).iterator())).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,DeprecatedString>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> entry = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,DeprecatedString> const key_value_ = entry;
+DeprecatedString const key = ((key_value_).template get<0>());
+DeprecatedString const value = ((key_value_).template get<1>());
+
+TRY((((((eval_scope)->type_bindings)).set(key,TRY((types::TypeId::from_string(value)))))));
 }
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Defer>(checked_statement,span))));
+
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::cast_to_underlying(NonnullRefPtr<typename parser::ParsedExpression> const expr,types::ScopeId const scope_id,NonnullRefPtr<typename parser::ParsedType> const parsed_type) {
-{
-NonnullRefPtr<typename parser::ParsedExpression> const cast_expression = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::TypeCast( parser::TypeCast { typename parser::TypeCast::Infallible(parsed_type) } ) } ,((expr)->span()))));
-return (TRY((((*this).typecheck_expression(cast_expression,scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone())))));
+if (((this_expr).has_value())){
+auto __jakt_var_471 = [&]() -> ErrorOr<void> {{
+interpreter::StatementResult const evaluated_this = TRY((((interpreter)->execute_expression((this_expr.value()),eval_scope))));
+if (((evaluated_this).index() == 5 /* JustValue */)){
+types::Value const value = ((evaluated_this).get<interpreter::StatementResult::JustValue>()).value;
+(this_argument = value);
 }
+else if (((evaluated_this).index() == 1 /* Throw */)){
+types::Value const value = ((evaluated_this).get<interpreter::StatementResult::Throw>()).value;
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Error executing this expression (evaluation threw {})"sv),value))),(((this_expr.value()))->span())))));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Invalid this expression"sv),(((this_expr.value()))->span())))));
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_comptime_index(NonnullRefPtr<typename parser::ParsedExpression> const expr,NonnullRefPtr<typename parser::ParsedExpression> const index,types::ScopeId const scope_id,bool const is_optional,types::SafetyMode const safety_mode,utility::Span const span) {
-{
-NonnullRefPtr<typename types::CheckedExpression> const checked_index = TRY((((*this).typecheck_expression(index,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-NonnullRefPtr<interpreter::Interpreter> interpreter = TRY((((*this).interpreter())));
-NonnullRefPtr<interpreter::InterpreterScope> scope = TRY((interpreter::InterpreterScope::from_runtime_scope(scope_id,((*this).program),JaktInternal::OptionalNone())));
-interpreter::StatementResult const index_result = ({ Optional<interpreter::StatementResult> __jakt_var_494;
-auto __jakt_var_495 = [&]() -> ErrorOr<interpreter::StatementResult> { return TRY((((interpreter)->execute_expression(checked_index,scope)))); }();
-if (__jakt_var_495.is_error()) {auto error = __jakt_var_495.release_error();
-{
-warnln(Jakt::DeprecatedString("Error while evaluating comptime index: {}"sv),error);
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::ComptimeIndex>(TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span)))),checked_index,is_optional,span))));
 }
-} else {__jakt_var_494 = __jakt_var_495.release_value();
+
+;return {};}();
+if (__jakt_var_471.is_error()) {{
+TRY((((*this).error(Jakt::DeprecatedString("Error executing this expression"sv),(((this_expr.value()))->span())))));
 }
-__jakt_var_494.release_value(); });
-typechecker::NumericOrStringValue const index_constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<typechecker::NumericOrStringValue, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = index_result;
-switch(__jakt_match_variant.index()) {
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
-types::Value const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<typechecker::NumericOrStringValue, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((value).impl);
+};
+}
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((args).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>> argument = (_magic_value.value());
+{
+interpreter::StatementResult const value = ({ Optional<interpreter::StatementResult> __jakt_var_472;
+auto __jakt_var_473 = [&]() -> ErrorOr<interpreter::StatementResult> { return TRY((((interpreter)->execute_expression(((argument).template get<1>()),eval_scope)))); }();
+if (__jakt_var_473.is_error()) {{
+TRY((((*this).error(Jakt::DeprecatedString("Error in argument"sv),span))));
+continue;
+}
+} else {__jakt_var_472 = __jakt_var_473.release_value();
+}
+__jakt_var_472.release_value(); });
+if (((value).index() == 1 /* Throw */)){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Compiletime call failed: {}"sv),value))),((((argument).template get<1>()))->span())))));
+break;
+}
+types::Value const evaluated_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = value;
 switch(__jakt_match_variant.index()) {
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
-DeprecatedString const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::StringValue(val) } );
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Return>();
+types::Value const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::UnsignedNumericValue((infallible_integer_cast<u64>((val)))) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( typechecker::NumericOrStringValue { typename typechecker::NumericOrStringValue::SignedNumericValue((infallible_integer_cast<i64>((val)))) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(x);
 };/*case end*/
 default: {
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index expression evaluation failed: expected numeric or string type, found {}"sv),((value).impl)))),span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
+return Error::from_errno(static_cast<i32>(69));
 }
 };/*case end*/
 }/*switch end*/
 }()
-)));
-};/*case end*/
-default: {
+));
+TRY((((call_args).push(evaluated_value))));
+}
+
+}
+}
+
+JaktInternal::Dictionary<DeprecatedString,types::TypeId> type_bindings = (TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({}))));
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Index expression evaluation returned an invalid object {}"sv),index_result))),span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((((resolved_function)->generics))->params)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-};/*case end*/
-}/*switch end*/
-}()
-));
+size_t i = (_magic_value.value());
+{
+types::FunctionGenericParameter const param = ((((((resolved_function)->generics))->params))[i]);
+TRY((((type_bindings).set(TRY((((((param).type_id())).to_string()))),((((function_call).type_args))[i])))));
+}
+
+}
+}
+
+JaktInternal::Optional<interpreter::ExecutionResult> result = JaktInternal::OptionalNone();
+NonnullRefPtr<interpreter::InterpreterScope> invocation_scope = TRY((interpreter::InterpreterScope::create((TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),JaktInternal::OptionalNone(),type_bindings)));
+auto __jakt_var_474 = [&]() -> ErrorOr<void> {{
+(result = TRY((((interpreter)->execute((resolved_function_id.value()),resolved_namespaces,this_argument,call_args,span,invocation_scope)))));
+}
+
+;return {};}();
+if (__jakt_var_474.is_error()) {auto error = __jakt_var_474.release_error();{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Compiletime call failed: {}"sv),error))),span))));
+return (checked_call);
+}
+};
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = index_constant;
+auto&& __jakt_match_variant = (result.value());
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename typechecker::NumericOrStringValue::StringValue>();
-DeprecatedString const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_struct(expr,val,scope_id,is_optional,safety_mode,span)))));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename typechecker::NumericOrStringValue::UnsignedNumericValue>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_tuple(expr,(infallible_integer_cast<size_t>((val))),scope_id,is_optional,safety_mode,span)))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Return>();
+types::Value const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((interpreter::value_to_checked_expression(x,interpreter))));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename typechecker::NumericOrStringValue::SignedNumericValue>();
-i64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_tuple(expr,(infallible_integer_cast<size_t>((val))),scope_id,is_optional,safety_mode,span)))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::ExecutionResult::Throw>();
+types::Value const& x = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_475; {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Compiletime call failed: {}"sv),x))),span))));
+__jakt_var_475 = checked_call; goto __jakt_label_425;
+
+}
+__jakt_label_425:; __jakt_var_475.release_value(); }));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
 }
+return (checked_call);
 }
-
-ErrorOr<void> typechecker::Typechecker::typecheck_struct_default_fields(parser::ParsedRecord const parsed_record,types::StructId const struct_id,types::ScopeId const scope_id) {
-{
-types::CheckedStruct structure = ((*this).get_struct(struct_id));
-types::ScopeId const checked_struct_scope_id = ((structure).scope_id);
-types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
-JaktInternal::Optional<types::TypeId> const previous_struct_type_id = ((*this).current_struct_type_id);
-(((*this).current_struct_type_id) = struct_type_id);
-ScopeGuard __jakt_var_496([&] {
-{
-(((*this).current_struct_type_id) = previous_struct_type_id);
 }
 
-});
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = struct_type_id);
-ScopeGuard __jakt_var_497([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
-JaktInternal::DynamicArray<parser::ParsedField> const parsed_fields = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<parser::ParsedField>, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((parsed_record).record_type);
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Struct>();JaktInternal::DynamicArray<parser::ParsedField> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(fields);
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Class>();JaktInternal::DynamicArray<parser::ParsedField> const& fields = __jakt_match_value.fields;
-return JaktInternal::ExplicitValue(fields);
-};/*case end*/
-default: {
+ErrorOr<JaktInternal::DynamicArray<types::FunctionId>> typechecker::Typechecker::resolve_call(parser::ParsedCall const call,JaktInternal::DynamicArray<types::ResolvedNamespace> namespaces,utility::Span const span,types::ScopeId const scope_id,bool const must_be_enum_constructor) {
 {
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_struct_default_fields cannot handle non-structs"sv)))));
-}
-};/*case end*/
-}/*switch end*/
-}()
-));
-i64 index = static_cast<i64>(0LL);
+types::ScopeId current_scope_id = scope_id;
+JaktInternal::DynamicArray<bool> is_base_ns_alias_or_import = (TRY((DynamicArray<bool>::filled(((namespaces).size()), false))));
 {
-JaktInternal::ArrayIterator<parser::ParsedField> _magic = ((parsed_fields).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((call).namespace_)).size()))});
 for (;;){
-JaktInternal::Optional<parser::ParsedField> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedField unchecked_member = (_magic_value.value());
+size_t namespace_index = (_magic_value.value());
 {
-ScopeGuard __jakt_var_498([&] {
-({auto& _jakt_ref = index;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
-});
-if (((!(((((unchecked_member).default_value)).has_value()))) || ((((((((structure).fields))[index])).default_value)).has_value()))){
+DeprecatedString const scope_name = ((((call).namespace_))[namespace_index]);
+JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const maybe_ns_scope = TRY((((*this).find_namespace_in_scope(current_scope_id,scope_name,false))));
+if (((maybe_ns_scope).has_value())){
+JaktInternal::Tuple<types::ScopeId,bool> const scope_id_is_import_ = (maybe_ns_scope.value());
+types::ScopeId const scope_id = ((scope_id_is_import_).template get<0>());
+bool const is_import = ((scope_id_is_import_).template get<1>());
+
+if (is_import){
+(((((namespaces)[namespace_index])).name) = ((((((((*this).program))->modules))[((((scope_id).module_id)).id)]))->name));
+}
+(((((namespaces)[namespace_index])).external_name) = ((TRY((((*this).get_scope(scope_id)))))->external_name));
+(((is_base_ns_alias_or_import)[namespace_index]) = (((TRY((((*this).find_namespace_in_scope(current_scope_id,scope_name,true)))).value())).template get<1>()));
+(current_scope_id = scope_id);
 continue;
 }
-(((((((structure).fields))[index])).default_value) = TRY((((*this).typecheck_expression((((unchecked_member).default_value).value()),checked_struct_scope_id, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone())))));
+JaktInternal::Optional<types::StructId> const maybe_struct_scope = TRY((((*this).find_struct_in_scope(current_scope_id,scope_name))));
+if (((maybe_struct_scope).has_value())){
+types::CheckedStruct const structure = ((*this).get_struct((maybe_struct_scope.value())));
+(((((namespaces)[namespace_index])).external_name) = ((structure).external_name));
+(current_scope_id = ((structure).scope_id));
+continue;
 }
-
+JaktInternal::Optional<types::EnumId> const maybe_enum_scope = TRY((((((*this).program))->find_enum_in_scope(current_scope_id,scope_name))));
+if (((maybe_enum_scope).has_value())){
+types::CheckedEnum const enum_ = ((*this).get_enum((maybe_enum_scope.value())));
+(current_scope_id = ((enum_).scope_id));
+continue;
 }
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Not a namespace, enum, class, or struct: ‘{}’"sv),utility::join(((call).namespace_),Jakt::DeprecatedString("::"sv))))),span))));
 }
 
 }
-return {};
 }
 
-ErrorOr<bool> typechecker::Typechecker::scope_lifetime_subsumes(JaktInternal::Optional<types::ScopeId> const larger,JaktInternal::Optional<types::ScopeId> const smaller,JaktInternal::Set<DeprecatedString>& checked) const {
+types::ScopeId initial_scope_id = current_scope_id;
+JaktInternal::Optional<types::ScopeId> owning_scope = JaktInternal::OptionalNone();
+ScopeGuard __jakt_var_476([&] {
 {
-if ((!(((larger).has_value())))){
-return (false);
-}
-if ((!(((smaller).has_value())))){
-return (true);
-}
-types::ScopeId const larger_id = (larger.value());
-types::ScopeId const smaller_id = (smaller.value());
-if (((((checked))).contains(TRY((((larger_id).to_string())))))){
-return (false);
-}
-TRY((((((checked))).add(TRY((((larger_id).to_string())))))));
-JaktInternal::Optional<types::ScopeId> scope_id = static_cast<JaktInternal::Optional<types::ScopeId>>(larger_id);
-bool first = true;
-while (((scope_id).has_value())){
-if (((!(first)) && (((scope_id.value())).equals(smaller_id)))){
-return (true);
-}
-(first = false);
-NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope((scope_id.value())))));
+JaktInternal::DynamicArray<types::ResolvedNamespace> resolved_namespaces = (MUST((DynamicArray<types::ResolvedNamespace>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
+i64 ns_index = static_cast<i64>(0LL);
+{
+JaktInternal::ArrayIterator<types::ResolvedNamespace> _magic = ((namespaces).iterator());
 for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::ResolvedNamespace> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ScopeId child_scope_id = (_magic_value.value());
+types::ResolvedNamespace ns = (_magic_value.value());
 {
-if (TRY((((*this).scope_lifetime_subsumes(child_scope_id,smaller_id,checked))))){
-return (true);
+ScopeGuard __jakt_var_477([&] {
+({auto& _jakt_ref = ns_index;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, static_cast<i64>(1LL));});
+});
+if ((!(((is_base_ns_alias_or_import)[ns_index])))){
+MUST((((resolved_namespaces).push(ns))));
 }
 }
 
 }
 }
 
-(scope_id = ((scope)->parent));
-}
-return (false);
-}
 }
 
-ErrorOr<bool> typechecker::Typechecker::scope_lifetime_subsumes(JaktInternal::Optional<types::ScopeId> const larger,JaktInternal::Optional<types::ScopeId> const smaller) const {
+if ((!(((owning_scope).has_value())))){
+JaktInternal::DynamicArray<types::ResolvedNamespace> aliased_namespaces = (MUST((DynamicArray<types::ResolvedNamespace>::create_with({}))));
+for (;;){
+NonnullRefPtr<types::Scope> const scope = MUST((((*this).get_scope(current_scope_id))));
+if (((((scope)->alias_path)).has_value())){
 {
-JaktInternal::Set<DeprecatedString> checked = (TRY((Set<DeprecatedString>::create_with_values({}))));
-return (TRY((((*this).scope_lifetime_subsumes(larger,smaller,((checked)))))));
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>((((((scope)->alias_path).value())).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+size_t i = (_magic_value.value());
+{
+MUST((((aliased_namespaces).push((((((scope)->alias_path).value()))[(JaktInternal::checked_sub<size_t>(i,static_cast<size_t>(1ULL)))])))));
 }
 
-ErrorOr<void> typechecker::Typechecker::check_method_access(types::ScopeId const accessor,types::ScopeId const accessee,NonnullRefPtr<types::CheckedFunction> const method,utility::Span const span) {
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((method)->visibility);
-switch(__jakt_match_variant.index()) {
-case 1: {
-{
-if ((!(TRY((((*this).scope_can_access(accessor,accessee))))))){
-if ((!(((((method)->type)).index() == 0 /* Normal */)))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Can't access constructor ‘{}’, because it is marked private"sv),((method)->name)))),span,Jakt::DeprecatedString("Private constructors are created if any fields are private"sv),span))));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't access method ‘{}’, because it is marked private"sv),((method)->name)))),span))));
 }
 
 }
+else if (((((scope)->namespace_name)).has_value())){
+MUST((((aliased_namespaces).push(types::ResolvedNamespace((((scope)->namespace_name).value()),((scope)->external_name),JaktInternal::OptionalNone())))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedVisibility::Restricted>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> const& scopes = __jakt_match_value.scopes;
-{
-TRY((((*this).check_restricted_access(accessor,Jakt::DeprecatedString("function"sv),accessee,((method)->name),scopes,span))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
+if (MUST((((*this).is_scope_directly_accessible_from(current_scope_id,initial_scope_id))))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+JaktInternal::Optional<types::ScopeId> const parent = ((scope)->parent);
+if ((!(((parent).has_value())))){
+break;
 }
-return {};
+(current_scope_id = (parent.value()));
 }
-
-ErrorOr<types::CheckedBlock> typechecker::Typechecker::typecheck_block(parser::ParsedBlock const parsed_block,types::ScopeId const parent_scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const yield_type_hint) {
-{
-bool const parent_throws = ((TRY((((*this).get_scope(parent_scope_id)))))->can_throw);
-types::ScopeId const block_scope_id = TRY((((*this).create_scope(parent_scope_id,parent_throws,Jakt::DeprecatedString("block"sv),true))));
-types::CheckedBlock checked_block = types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false);
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((parsed_block).stmts)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(((aliased_namespaces).size())),static_cast<size_t>(static_cast<size_t>(0ULL))});
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedStatement> parsed_statement = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-if ((!(((((checked_block).control_flow)).is_reachable())))){
-TRY((((*this).error(Jakt::DeprecatedString("Unreachable code"sv),((parsed_statement)->span())))));
+MUST((((resolved_namespaces).push(((aliased_namespaces)[(JaktInternal::checked_sub<size_t>(i,static_cast<size_t>(1ULL)))])))));
 }
-NonnullRefPtr<typename types::CheckedStatement> const checked_statement = TRY((((*this).typecheck_statement(parsed_statement,block_scope_id,safety_mode,yield_type_hint))));
-(((checked_block).control_flow) = ((((checked_block).control_flow)).updated(((*this).statement_control_flow(checked_statement)))));
-JaktInternal::Optional<utility::Span> const yield_span = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<utility::Span>, ErrorOr<types::CheckedBlock>>{
-auto&& __jakt_match_variant = *parsed_statement;
+
+}
+}
+
+}
+((namespaces).shrink(static_cast<size_t>(0ULL)));
+MUST((((namespaces).push_values(((resolved_namespaces))))));
+}
+
+});
+JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const maybe_var = TRY((((*this).find_var_in_scope(current_scope_id,((call).name)))));
+if (((maybe_var).has_value())){
+types::TypeId const inner_type = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<JaktInternal::DynamicArray<types::FunctionId>>>{
+auto&& __jakt_match_variant = *((*this).get_type((((maybe_var.value()))->type_id)));
 switch(__jakt_match_variant.index()) {
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Yield>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<utility::Span>>(((expr)->span())));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedStatement::Guard>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<utility::Span>>(((expr)->span())));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(type_id);
 };/*case end*/
-}/*switch end*/
-}()
-));
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const checked_yield_expression = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>, ErrorOr<types::CheckedBlock>>{
-auto&& __jakt_match_variant = *checked_statement;
-switch(__jakt_match_variant.index()) {
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>>>(expr));
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(type_id);
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+return JaktInternal::ExplicitValue((((maybe_var.value()))->type_id));
 };/*case end*/
 }/*switch end*/
 }()
 ));
-if ((((yield_span).has_value()) && ((checked_yield_expression).has_value()))){
-types::TypeId const type_var_type_id = (((checked_yield_expression.value()))->type());
-types::TypeId const type_ = TRY((((*this).resolve_type_var(type_var_type_id,block_scope_id))));
-if ((((checked_yield_expression.value()))->index() == 25 /* OptionalNone */)){
-(((checked_block).yielded_none) = true);
-}
-if (((((checked_block).yielded_type)).has_value())){
-TRY((((*this).check_types_for_compat(((((checked_block).yielded_type)).value()),type_,((((*this).generic_inferences))),((yield_span).value())))));
+if (((((*this).get_type(inner_type)))->index() == 29 /* Function */)){
+types::FunctionId const pseudo_function_id = ((((*this).get_type(inner_type)))->get<types::Type::Function>()).pseudo_function_id;
+return ((TRY((DynamicArray<types::FunctionId>::create_with({pseudo_function_id})))));
 }
-else {
-(((checked_block).yielded_type) = static_cast<JaktInternal::Optional<types::TypeId>>(type_));
 }
-
+JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>> const maybe_overload_set = TRY((((*this).find_scoped_functions_with_name_in_scope(current_scope_id,((call).name)))));
+if (((maybe_overload_set).has_value())){
+NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function((((((maybe_overload_set.value())).template get<0>()))[static_cast<i64>(0LL)])));
+if (((!(must_be_enum_constructor)) || ((((function)->type)).index() == 3 /* ImplicitEnumConstructor */))){
+(owning_scope = ((function)->owner_scope));
+(current_scope_id = (((maybe_overload_set.value())).template get<1>()));
+return ((((maybe_overload_set.value())).template get<0>()));
 }
-TRY((((((checked_block).statements)).push(checked_statement))));
 }
-
+if (must_be_enum_constructor){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("No such enum constructor ‘{}’"sv),((call).name)))),span))));
+return ((TRY((DynamicArray<types::FunctionId>::create_with({})))));
 }
+JaktInternal::Optional<types::StructId> const maybe_struct_id = TRY((((*this).find_struct_in_scope(current_scope_id,((call).name)))));
+if (((maybe_struct_id).has_value())){
+types::StructId const struct_id = (maybe_struct_id.value());
+types::CheckedStruct const structure = ((*this).get_struct(struct_id));
+JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>> const maybe_function_id = TRY((((*this).find_scoped_functions_with_name_in_scope(((structure).scope_id),((structure).name)))));
+if (((maybe_function_id).has_value())){
+(current_scope_id = (((maybe_function_id.value())).template get<1>()));
+return ((((maybe_function_id.value())).template get<0>()));
 }
-
-if (((((checked_block).yielded_type)).has_value())){
-(((checked_block).yielded_type) = static_cast<JaktInternal::Optional<types::TypeId>>(TRY((((*this).substitute_typevars_in_type(((((checked_block).yielded_type)).value()),((*this).generic_inferences)))))));
 }
-return (checked_block);
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Call to unknown function: ‘{}’"sv),((call).name)))),span))));
+return ((TRY((DynamicArray<types::FunctionId>::create_with({})))));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_loop(parser::ParsedBlock const parsed_block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_if(NonnullRefPtr<typename parser::ParsedExpression> const condition,parser::ParsedBlock const then_block,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const else_statement,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
 {
-types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(parsed_block,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const new_condition_new_then_block_new_else_statement_ = TRY((((*this).expand_context_for_bindings(condition,JaktInternal::OptionalNone(),then_block,else_statement,span))));
+NonnullRefPtr<typename parser::ParsedExpression> const new_condition = ((new_condition_new_then_block_new_else_statement_).template get<0>());
+JaktInternal::Optional<parser::ParsedBlock> const new_then_block = ((new_condition_new_then_block_new_else_statement_).template get<1>());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const new_else_statement = ((new_condition_new_then_block_new_else_statement_).template get<2>());
+
+NonnullRefPtr<typename types::CheckedExpression> const checked_condition = TRY((((*this).typecheck_expression_and_dereference_if_needed(new_condition,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+if ((!(((((checked_condition)->type())).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
+TRY((((*this).error(Jakt::DeprecatedString("Condition must be a boolean expression"sv),((new_condition)->span())))));
+}
+types::CheckedBlock const checked_block = TRY((((*this).typecheck_block((new_then_block.value()),scope_id,safety_mode,JaktInternal::OptionalNone()))));
 if (((((checked_block).yielded_type)).has_value())){
-TRY((((*this).error(Jakt::DeprecatedString("A ‘loop’ block is not allowed to yield values"sv),(((parsed_block).find_yield_span()).value())))));
+TRY((((*this).error(Jakt::DeprecatedString("An 'if' block is not allowed to yield values"sv),((((new_then_block.value())).find_yield_span()).value())))));
 }
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Loop>(checked_block,span))));
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> checked_else = JaktInternal::OptionalNone();
+if (((new_else_statement).has_value())){
+(checked_else = TRY((((*this).typecheck_statement((new_else_statement.value()),scope_id,safety_mode,JaktInternal::OptionalNone())))));
+}
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::If>(checked_condition,checked_block,checked_else,span))));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_generic_arguments_method_call(NonnullRefPtr<typename types::CheckedExpression> const checked_expr,parser::ParsedCall const call,types::ScopeId const scope_id,utility::Span const span,bool const is_optional,types::SafetyMode const safety_mode) {
+ErrorOr<void> typechecker::Typechecker::check_implicit_constructor_argument_access(types::ScopeId const caller_scope_id,parser::ParsedCall const call,types::CheckedStruct const struct_) {
 {
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> checked_args = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
-TRY((((checked_args).ensure_capacity(((((call).args)).size())))));
+if ((!(TRY((((*this).scope_can_access(caller_scope_id,((struct_).scope_id)))))))){
 {
 JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((((call).args)).iterator());
 for (;;){
@@ -9162,119 +8979,114 @@ JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span,Nonnul
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> name_____expr__ = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> arg = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const jakt__name_____expr__ = name_____expr__;
-DeprecatedString const name = ((jakt__name_____expr__).template get<0>());
-utility::Span const _ = ((jakt__name_____expr__).template get<1>());
-NonnullRefPtr<typename parser::ParsedExpression> const expr = ((jakt__name_____expr__).template get<2>());
-
-NonnullRefPtr<typename types::CheckedExpression> const checked_arg_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-TRY((((checked_args).push((Tuple{name, checked_arg_expr})))));
-}
-
-}
-}
-
-JaktInternal::DynamicArray<types::TypeId> checked_type_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((call).type_args)).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((struct_).fields)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedType> type_arg = (_magic_value.value());
+types::CheckedField field = (_magic_value.value());
 {
-TRY((((checked_type_args).push(TRY((((*this).typecheck_typename(type_arg,scope_id,JaktInternal::OptionalNone()))))))));
+NonnullRefPtr<types::CheckedVariable> const variable = ((*this).get_variable(((field).variable_id)));
+DeprecatedString const name = ((*this).get_argument_name(arg));
+if (((((variable)->name) == name) && ((((variable)->visibility)).index() == 1 /* Private */))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't access field '{}' when calling implicit constructor of '{}' because it is marked private"sv),((variable)->name),((struct_).name)))),((arg).template get<1>())))));
+return {};
+}
 }
 
 }
 }
 
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::MethodCall>(checked_expr,types::CheckedCall((TRY((DynamicArray<types::ResolvedNamespace>::create_with({})))),((call).name),checked_args,checked_type_args,JaktInternal::OptionalNone(),types::unknown_type_id(),false,JaktInternal::OptionalNone()),span,is_optional,types::unknown_type_id()))));
+}
+
 }
 }
 
-ErrorOr<bool> typechecker::Typechecker::check_restricted_access(types::ScopeId const accessor,DeprecatedString const accessee_kind,types::ScopeId const accessee,DeprecatedString const name,JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> const whitelist,utility::Span const span) {
-{
-types::ScopeId const most_specific_active_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId,ErrorOr<bool>>{
-auto __jakt_enum_value = (((((*this).current_function_id)).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((((*this).get_function((((*this).current_function_id).value()))))->function_scope_id));
 }
-else {
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_499; {
-if ((!(((((*this).current_struct_type_id)).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't access {0} ‘{1}’ from this global scope, because ‘{1}’ restricts access to it"sv),accessee_kind,name))),span))));
-return (false);
 }
-__jakt_var_499 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId, ErrorOr<bool>>{
-auto&& __jakt_match_variant = *((*this).get_type((((*this).current_struct_type_id).value())));
-switch(__jakt_match_variant.index()) {
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((((*this).get_struct(id))).scope_id));
-};/*case end*/
-default: {
-{
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Internal error: current_struct_type_id is not a struct"sv),span))));
+return {};
 }
-};/*case end*/
-}/*switch end*/
-}()
-)); goto __jakt_label_451;
 
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_expression_and_dereference_if_needed(NonnullRefPtr<typename parser::ParsedExpression> const expr,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint,utility::Span const span) {
+{
+NonnullRefPtr<typename types::CheckedExpression> checked_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,type_hint))));
+return (TRY((((*this).dereference_if_needed(checked_expr,span)))));
 }
-__jakt_label_451:; __jakt_var_499.release_value(); }));
 }
-}()))
-;
+
+ErrorOr<void> typechecker::Typechecker::typecheck_enum(parser::ParsedRecord const record,types::EnumId const enum_id,types::ScopeId const parent_scope_id) {
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::MaybeResolvedScope>> _magic = ((whitelist).iterator());
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = ((((*this).get_enum(enum_id))).type_id));
+ScopeGuard __jakt_var_478([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+{
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((record).methods)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::MaybeResolvedScope>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename types::MaybeResolvedScope> scope = (_magic_value.value());
+parser::ParsedMethod method = (_magic_value.value());
 {
-NonnullRefPtr<typename types::MaybeResolvedScope> const resolved_scope = TRY((((scope)->try_resolve(((*this).program)))));
-if (((resolved_scope)->index() == 0 /* Resolved */)){
-types::ScopeId const scope_id = ((resolved_scope)->get<types::MaybeResolvedScope::Resolved>()).value;
-if (TRY((((*this).scope_can_access(most_specific_active_scope_id,scope_id))))){
-return (true);
+TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),enum_id) } ))));
 }
+
 }
-else {
-continue;
 }
 
+}
+return {};
 }
 
+ErrorOr<JaktInternal::Optional<types::TypeId>> typechecker::Typechecker::find_type_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
+{
+return (((TRY((((*this).find_type_scope(scope_id,name))))).map([](auto& _value) { return _value.template get<0>(); })));
+}
+}
+
+ErrorOr<JaktInternal::Optional<types::CheckedEnumVariant>> typechecker::Typechecker::get_enum_variant(types::CheckedEnum const enum_,DeprecatedString const variant_name) {
+{
+{
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedEnumVariant variant = (_magic_value.value());
+{
+if ((((variant).name()) == variant_name)){
+return (variant);
 }
 }
 
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(most_specific_active_scope_id))));
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot access {} ‘{}’ from this scope"sv),accessee_kind,name))),span))));
-return (false);
 }
 }
 
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>>> typechecker::Typechecker::get_type_ids_from_type_hint_if_struct_ids_match(JaktInternal::Optional<types::TypeId> const type_hint,types::StructId const expected_struct_id) const {
-{
-if ((!(((type_hint).has_value())))){
 return (JaktInternal::OptionalNone());
 }
-if (((TRY((((*this).unwrap_type_from_optional_if_needed(((*this).get_type((type_hint.value()))))))))->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((TRY((((*this).unwrap_type_from_optional_if_needed(((*this).get_type((type_hint.value()))))))))->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((TRY((((*this).unwrap_type_from_optional_if_needed(((*this).get_type((type_hint.value()))))))))->get<types::Type::GenericInstance>()).args;
-if (((id).equals(expected_struct_id))){
-return (args);
 }
+
+ErrorOr<bool> typechecker::Typechecker::scope_can_access(types::ScopeId const accessor,types::ScopeId const accessee) const {
+{
+if (((accessor).equals(accessee))){
+return (true);
+}
+NonnullRefPtr<types::Scope> accessor_scope = TRY((((*this).get_scope(accessor))));
+while (((((accessor_scope)->parent)).has_value())){
+types::ScopeId const parent = (((accessor_scope)->parent).value());
+if (((parent).equals(accessee))){
+return (true);
 }
-return (JaktInternal::OptionalNone());
+(accessor_scope = TRY((((*this).get_scope(parent)))));
+}
+return (false);
 }
 }
 
@@ -9310,2814 +9122,2966 @@ return (reverse_chain);
 }
 }
 
-ErrorOr<bool> typechecker::Typechecker::add_function_to_scope(types::ScopeId const parent_scope_id,DeprecatedString const name,JaktInternal::DynamicArray<types::FunctionId> const overload_set,utility::Span const span) {
-{
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(parent_scope_id))));
-if (((((scope)->functions)).contains(name))){
-JaktInternal::DynamicArray<types::FunctionId> const existing_function_binding = ((((scope)->functions))[name]);
-{
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::FunctionId function_id = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedFunction> const function_to_add = ((*this).get_function(function_id));
-{
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((existing_function_binding).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::FunctionId existing_function_id = (_magic_value.value());
+ErrorOr<bool> typechecker::Typechecker::type_contains_reference(types::TypeId const type_id) {
 {
-NonnullRefPtr<types::CheckedFunction> const existing_function = ((*this).get_function(existing_function_id));
-if (TRY((((function_to_add)->signature_matches(existing_function))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of function ‘{}’."sv),((function_to_add)->name)))),(((((function_to_add)->parsed_function).value())).name_span),Jakt::DeprecatedString("Previous definition is here"sv),(((((existing_function)->parsed_function).value())).name_span)))));
+NonnullRefPtr<typename types::Type> const type = ((*this).get_type(type_id));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<bool>>{
+auto&& __jakt_match_variant = *type;
+switch(__jakt_match_variant.index()) {
+case 27: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 28: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_for(DeprecatedString const iterator_name,utility::Span const name_span,bool const is_destructuring,NonnullRefPtr<typename parser::ParsedExpression> const range,parser::ParsedBlock const block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+{
+JaktInternal::Optional<utility::Span> const maybe_span = ((block).find_yield_span());
+if (((maybe_span).has_value())){
+TRY((((*this).error(Jakt::DeprecatedString("a 'for' loop block is not allowed to yield values"sv),(maybe_span.value())))));
 }
+NonnullRefPtr<typename types::CheckedExpression> iterable_expr = TRY((((*this).typecheck_expression(range,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+types::TypeId resolved_iterable_result_type = types::unknown_type_id();
+NonnullRefPtr<typename parser::ParsedExpression> expression_to_iterate = range;
+JaktInternal::Optional<typechecker::TraitImplementationDescriptor> const iterable_trait_implementation = TRY((((*this).find_any_singular_trait_implementation(((iterable_expr)->type()),(TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("Iterable"sv), Jakt::DeprecatedString("ThrowingIterable"sv)})))),scope_id,((iterable_expr)->span())))));
+if ((!(((iterable_trait_implementation).has_value())))){
+JaktInternal::Optional<typechecker::TraitImplementationDescriptor> const into_iterator_trait_implementation = TRY((((*this).find_any_singular_trait_implementation(((iterable_expr)->type()),(TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("IntoIterator"sv), Jakt::DeprecatedString("IntoThrowingIterator"sv)})))),scope_id,((iterable_expr)->span())))));
+if ((!(((into_iterator_trait_implementation).has_value())))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Iterable expression is not iterable"sv),((range)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Consider implementing (Throwing)Iterable<T> or Into(Throwing)Iterator<T> for the type of this expression (‘{}’)"sv),TRY((((*this).type_name(((iterable_expr)->type()),false))))))),((range)->span())))));
 }
-
-TRY((((((((scope)->functions))[name])).push(function_id))));
+else {
+(resolved_iterable_result_type = (((((into_iterator_trait_implementation.value())).implemented_type_args))[static_cast<i64>(0LL)]));
+(expression_to_iterate = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(range,parser::ParsedCall((TRY((DynamicArray<DeprecatedString>::create_with({})))),Jakt::DeprecatedString("iterator"sv),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))))),false,name_span))));
 }
 
 }
+else {
+(resolved_iterable_result_type = (((((iterable_trait_implementation.value())).implemented_type_args))[static_cast<i64>(0LL)]));
 }
 
+NonnullRefPtr<typename parser::ParsedStatement> const rewritten_statement = TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(parser::ParsedVarDecl(Jakt::DeprecatedString("_magic"sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),true,JaktInternal::OptionalNone(),name_span),expression_to_iterate,span))), TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Loop>(parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(parser::ParsedVarDecl(Jakt::DeprecatedString("_magic_value"sv),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),false,JaktInternal::OptionalNone(),name_span),TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("_magic"sv),name_span))),parser::ParsedCall((TRY((DynamicArray<DeprecatedString>::create_with({})))),Jakt::DeprecatedString("next"sv),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))))),false,name_span))),span))), TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::If>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::MethodCall>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("_magic_value"sv),name_span))),parser::ParsedCall((TRY((DynamicArray<DeprecatedString>::create_with({})))),Jakt::DeprecatedString("has_value"sv),(TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedType>>::create_with({}))))),false,name_span))), parser::UnaryOperator { typename parser::UnaryOperator::LogicalNot() } ,name_span))),parser::ParsedBlock((TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Break>(span)))}))))),JaktInternal::OptionalNone(),span))), TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(parser::ParsedVarDecl(iterator_name,TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),true,JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<utility::Span>,ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
+auto __jakt_enum_value = (is_destructuring);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
 }
 else {
-TRY((((((scope)->functions)).set(name,overload_set))));
+return JaktInternal::ExplicitValue(name_span);
 }
-
-TRY((((*this).set_owner_scope_if_needed(parent_scope_id,overload_set))));
-return (true);
+}()))
+,name_span),TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::ForcedUnwrap>(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::Var>(Jakt::DeprecatedString("_magic_value"sv),name_span))),name_span))),span))), TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::Block>(block,span)))}))))),span)))}))))),span)));
+return (TRY((((*this).typecheck_statement(rewritten_statement,scope_id,safety_mode,JaktInternal::OptionalNone())))));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_expression_and_dereference_if_needed(NonnullRefPtr<typename parser::ParsedExpression> const expr,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint,utility::Span const span) {
+ErrorOr<JaktInternal::Optional<types::FunctionId>> typechecker::Typechecker::find_function_matching_signature_in_scope(types::ScopeId const parent_scope_id,parser::ParsedFunction const prototype) const {
 {
-NonnullRefPtr<typename types::CheckedExpression> checked_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,type_hint))));
-return (TRY((((*this).dereference_if_needed(checked_expr,span)))));
-}
-}
-
-ErrorOr<jakt__path::Path> typechecker::Typechecker::get_root_path() const {
+DeprecatedString const function_name = ((prototype).name);
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const candidate_ids = TRY((((((*this).program))->find_functions_with_name_in_scope(parent_scope_id,function_name))));
+if (((candidate_ids).has_value())){
 {
-JaktInternal::Optional<types::LoadedModule> const root_module = ((((*this).program))->get_loaded_module(((*this).root_module_name)));
-if (((root_module).has_value())){
-utility::FileId const file_id = (((root_module.value())).file_id);
-return ((TRY((((((*this).compiler))->get_file_path(file_id)))).value()));
+JaktInternal::ArrayIterator<types::FunctionId> _magic = (((candidate_ids.value())).iterator());
+for (;;){
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return (TRY((jakt__path::Path::from_string(Jakt::DeprecatedString("."sv)))));
+types::FunctionId candidate_id = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedFunction> const candidate = ((*this).get_function(candidate_id));
+if ((((((candidate)->parsed_function)).has_value()) && (((((candidate)->parsed_function).value())).equals(prototype)))){
+return (candidate_id);
 }
 }
 
-ErrorOr<bool> typechecker::Typechecker::scope_can_access(types::ScopeId const accessor,types::ScopeId const accessee) const {
-{
-if (((accessor).equals(accessee))){
-return (true);
 }
-NonnullRefPtr<types::Scope> accessor_scope = TRY((((*this).get_scope(accessor))));
-while (((((accessor_scope)->parent)).has_value())){
-types::ScopeId const parent = (((accessor_scope)->parent).value());
-if (((parent).equals(accessee))){
-return (true);
 }
-(accessor_scope = TRY((((*this).get_scope(parent)))));
+
 }
-return (false);
+return (JaktInternal::OptionalNone());
 }
 }
 
-ErrorOr<typechecker::FunctionMatchResult> typechecker::Typechecker::match_function_and_resolve_args(parser::ParsedCall const call,types::ScopeId const caller_scope_id,types::FunctionId const candidate,types::SafetyMode const safety_mode,utility::Span const span,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const this_expr) {
-{
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> args = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedExpression>>::create_with({}))));
-JaktInternal::Optional<types::TypeId> maybe_this_type_id = JaktInternal::OptionalNone();
-JaktInternal::DynamicArray<error::JaktError> argument_errors = (TRY((DynamicArray<error::JaktError>::create_with({}))));
-size_t const num_old_compiler_errors = ((((((*this).compiler))->errors)).size());
-NonnullRefPtr<types::CheckedFunction> const callee_candidate = ((*this).get_function(candidate));
-types::ScopeId const scope_containing_callee = (((TRY((((*this).get_scope(((callee_candidate)->function_scope_id))))))->parent).value());
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const generic_inference_checkpoint = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-if (((callee_candidate)->is_instantiated)){
-TRY((((((*this).generic_inferences)).perform_checkpoint(true))));
-}
-ScopeGuard __jakt_var_500([&] {
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_array(types::ScopeId const scope_id,JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const values,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const fill_size,utility::Span const span,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
 {
-((((*this).generic_inferences)).restore(generic_inference_checkpoint));
+if (((*this).dump_try_hints)){
+TRY((((*this).dump_try_hint(span))));
 }
-
-});
-if (((((callee_candidate)->type)).index() == 2 /* ImplicitConstructor */)){
-types::CheckedStruct const struct_ = ((*this).get_struct((((callee_candidate)->struct_id).value())));
-TRY((((*this).check_implicit_constructor_argument_access(caller_scope_id,call,struct_))));
+if ((!(((TRY((((*this).get_scope(scope_id)))))->can_throw)))){
+DeprecatedString const message = Jakt::DeprecatedString("Array initialization inside non-throwing scope"sv);
+if (((((*this).current_function_id)).has_value())){
+NonnullRefPtr<types::CheckedFunction> const current_function = ((*this).get_function((((*this).current_function_id).value())));
+TRY((((*this).error_with_hint(message,span,TRY((__jakt_format(Jakt::DeprecatedString("Add `throws` keyword to function {}"sv),((current_function)->name)))),((current_function)->name_span)))));
 }
 else {
-TRY((((*this).check_method_access(caller_scope_id,scope_containing_callee,callee_candidate,span))));
+TRY((((*this).error(message,span))));
 }
 
-size_t type_arg_index = static_cast<size_t>(0ULL);
+}
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> repeat = JaktInternal::OptionalNone();
+if (((fill_size).has_value())){
+NonnullRefPtr<typename parser::ParsedExpression> const fill_size_value = ((fill_size).value());
+NonnullRefPtr<typename types::CheckedExpression> const fill_size_checked = TRY((((*this).typecheck_expression_and_dereference_if_needed(fill_size_value,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+types::TypeId const fill_size_type = ((fill_size_checked)->type());
+if ((!(((*this).is_integer(fill_size_type))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' is not convertible to an integer. Only integer values can be array fill size expressions."sv),TRY((((*this).type_name(fill_size_type,false))))))),((fill_size_value)->span())))));
+}
+(repeat = fill_size_checked);
+}
+types::StructId const array_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+types::TypeId inner_type_id = types::unknown_type_id();
+JaktInternal::Optional<utility::Span> inferred_type_span = JaktInternal::OptionalNone();
+JaktInternal::Optional<types::TypeId> inner_hint = JaktInternal::OptionalNone();
+JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const type_hint_ids = TRY((((*this).get_type_ids_from_type_hint_if_struct_ids_match(type_hint,array_struct_id))));
+if (((type_hint_ids).has_value())){
+(inner_hint = (((type_hint_ids.value()))[static_cast<i64>(0LL)]));
+}
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> vals = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedExpression>>::create_with({}))));
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((call).type_args)).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedExpression>> _magic = ((values).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedType> parsed_type = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedExpression> value = (_magic_value.value());
 {
-types::TypeId const checked_type = TRY((((*this).typecheck_typename(parsed_type,caller_scope_id,JaktInternal::OptionalNone()))));
-if ((((((((callee_candidate)->generics))->params)).size()) <= type_arg_index)){
-TRY((((*this).error(Jakt::DeprecatedString("Trying to access generic parameter out of bounds"sv),((parsed_type)->span())))));
-continue;
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression(value,scope_id,safety_mode,inner_hint))));
+types::TypeId const current_value_type_id = ((checked_expr)->type());
+if (((current_value_type_id).equals(types::void_type_id()))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot create an array with values of type void\n"sv),span))));
 }
-types::TypeId const typevar_type_id = ((((((((callee_candidate)->generics))->params))[type_arg_index])).type_id());
-if ((!(((typevar_type_id).equals(checked_type))))){
-TRY((((((*this).generic_inferences)).set(TRY((((typevar_type_id).to_string()))),TRY((((checked_type).to_string())))))));
+if (((inner_type_id).equals(types::unknown_type_id()))){
+(inner_type_id = current_value_type_id);
+(inferred_type_span = ((value)->span()));
 }
-({auto& _jakt_ref = type_arg_index;_jakt_ref = JaktInternal::checked_add<size_t>(_jakt_ref, static_cast<size_t>(1ULL));});
+else if ((!(((inner_type_id).equals(current_value_type_id))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' does not match type '{}' of previous values in array"sv),TRY((((*this).type_name(current_value_type_id,false)))),TRY((((*this).type_name(inner_type_id,false))))))),((value)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Array was inferred to store type '{}' here"sv),TRY((((*this).type_name(inner_type_id,false))))))),(inferred_type_span.value())))));
+}
+TRY((((vals).push(checked_expr))));
 }
 
 }
 }
 
-size_t arg_offset = static_cast<size_t>(0ULL);
-if (((this_expr).has_value())){
-types::TypeId const type_id = (((this_expr.value()))->type());
-(maybe_this_type_id = type_id);
-NonnullRefPtr<typename types::Type> const param_type = ((*this).get_type(type_id));
-if (((param_type)->index() == 19 /* GenericInstance */)){
-types::StructId const id = ((param_type)->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const args = ((param_type)->get<types::Type::GenericInstance>()).args;
-types::CheckedStruct const structure = ((*this).get_struct(id));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((structure).generic_parameters)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
-{
-if (((((((((structure).generic_parameters))[i])).type_id)).equals(((args)[i])))){
-continue;
-}
-TRY((((((*this).generic_inferences)).set(TRY((((((((((structure).generic_parameters))[i])).type_id)).to_string()))),TRY((((((args)[i])).to_string())))))));
+if (((inner_type_id).equals(types::unknown_type_id()))){
+if (((inner_hint).has_value())){
+(inner_type_id = (inner_hint.value()));
 }
-
+else if ((((type_hint).has_value()) && (((type_hint.value())).equals(types::unknown_type_id())))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot infer generic type for Array<T>"sv),span))));
 }
 }
-
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id})))))))))));
+if (((type_hint).has_value())){
+TRY((((*this).check_types_for_compat((type_hint.value()),type_id,((((*this).generic_inferences))),span))));
 }
-if (((callee_candidate)->is_static())){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot call static method on an instance of an object"sv),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::JaktArray>(vals,repeat,span,type_id,inner_type_id))));
 }
-else {
-(arg_offset = static_cast<size_t>(1ULL));
 }
 
-if ((((callee_candidate)->is_mutating()) && (!((((this_expr.value()))->is_mutable(((*this).program))))))){
-TRY((((*this).error(Jakt::DeprecatedString("Cannot call mutating method on an immutable object instance"sv),span))));
-}
-}
-else if ((!(((callee_candidate)->is_static())))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Cannot call an instance method statically"sv),span,Jakt::DeprecatedString("Add a dot before the method name to call an instance method"sv),span))));
-}
-i64 total_function_specificity = static_cast<i64>(0LL);
-JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>> const resolved_args = TRY((((*this).resolve_default_params(((((callee_candidate)->generics))->base_params),((call).args),caller_scope_id,safety_mode,arg_offset,span))));
-if ((((((((callee_candidate)->generics))->base_params)).size()) == (JaktInternal::checked_add<size_t>(((resolved_args).size()),arg_offset)))){
+ErrorOr<void> typechecker::Typechecker::typecheck_trait_predecl(parser::ParsedTrait const parsed_trait,types::ScopeId const scope_id) {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>((JaktInternal::checked_sub<size_t>(((((((callee_candidate)->generics))->base_params)).size()),arg_offset)))});
+types::ScopeId const trait_scope_id = TRY((((*this).create_scope(scope_id,false,TRY((__jakt_format(Jakt::DeprecatedString("trait({})"sv),((parsed_trait).name)))),false))));
+TRY((((*this).add_type_to_scope(trait_scope_id,Jakt::DeprecatedString("Self"sv),TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Self>())))))),((parsed_trait).name_span)))));
+NonnullRefPtr<types::CheckedTrait> checked_trait = TRY((types::CheckedTrait::__jakt_create(((parsed_trait).name),((parsed_trait).name_span),(TRY((Dictionary<DeprecatedString, types::FunctionId>::create_with_entries({})))),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),trait_scope_id)));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::TraitId const trait_id = types::TraitId(((*this).current_module_id),((((((((((*this).program))->modules))[((((*this).current_module_id)).id)]))->traits)).size()));
+types::TypeId const trait_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Trait>(trait_id)))))));
+TRY((((((((((((*this).program))->modules))[((((*this).current_module_id)).id)]))->traits)).push(checked_trait))));
+JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
+(((*this).self_type_id) = trait_type_id);
+ScopeGuard __jakt_var_479([&] {
+(((*this).self_type_id) = old_self_type_id);
+});
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
+TRY((((*this).add_type_to_scope(scope_id,((parsed_trait).name),trait_type_id,((parsed_trait).name_span)))));
+TRY((((*this).add_trait_to_scope(scope_id,((parsed_trait).name),trait_id,((parsed_trait).name_span)))));
+JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters = ((((((module)->traits))[((trait_id).id)]))->generic_parameters);
+TRY((((generic_parameters).ensure_capacity(((((parsed_trait).generic_parameters)).size())))));
+{
+JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((parsed_trait).generic_parameters)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+parser::ParsedGenericParameter gen_parameter = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>> const name_span_checked_arg_ = ((resolved_args)[i]);
-DeprecatedString const name = ((name_span_checked_arg_).template get<0>());
-utility::Span const span = ((name_span_checked_arg_).template get<1>());
-NonnullRefPtr<typename types::CheckedExpression> const checked_arg = ((name_span_checked_arg_).template get<2>());
-
-NonnullRefPtr<typename types::Type> const type_to = ((*this).get_type(((((((((((callee_candidate)->generics))->base_params))[(JaktInternal::checked_add<size_t>(i,arg_offset))])).variable))->type_id)));
-({auto& _jakt_ref = total_function_specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((type_to)->specificity(((*this).program),(static_cast<i64>(1LL) << static_cast<i64>(31LL)))));});
-TRY((((*this).check_types_for_compat(((((((((((callee_candidate)->generics))->base_params))[(JaktInternal::checked_add<size_t>(i,arg_offset))])).variable))->type_id),((checked_arg)->type()),((((*this).generic_inferences))),((checked_arg)->span())))));
-TRY((((args).push(checked_arg))));
+types::TypeId const parameter_type_id = types::TypeId(((*this).current_module_id),((((((*this).current_module()))->types)).size()));
+JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+types::CheckedGenericParameter parameter = TRY((types::CheckedGenericParameter::make(parameter_type_id,((gen_parameter).span))));
+TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((gen_parameter).name),trait_implementations)))))));
+if (((((gen_parameter).requires_list)).has_value())){
+TRY((((*this).fill_trait_requirements((((gen_parameter).requires_list).value()),((((parameter).constraints))),((trait_implementations)),scope_id))));
+}
+TRY((((generic_parameters).push(parameter))));
+TRY((((*this).add_type_to_scope(trait_scope_id,((gen_parameter).name),parameter_type_id,((gen_parameter).span)))));
 }
 
 }
 }
 
-}
-size_t const num_match_errors = (JaktInternal::checked_sub<size_t>(((((((*this).compiler))->errors)).size()),num_old_compiler_errors));
-if ((num_match_errors > static_cast<size_t>(0ULL))){
+types::StructId const synthetic_struct_id = types::StructId(((*this).current_module_id),((((((((((*this).program))->modules))[((((*this).current_module_id)).id)]))->structures)).size()));
+TRY((((((module)->structures)).push(types::CheckedStruct(((parsed_trait).name),((parsed_trait).name_span),generic_parameters,(TRY((DynamicArray<types::CheckedField>::create_with({})))),trait_scope_id, parser::DefinitionLinkage { typename parser::DefinitionLinkage::External() } ,(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))), parser::RecordType { typename parser::RecordType::Struct((TRY((DynamicArray<parser::ParsedField>::create_with({})))),JaktInternal::OptionalNone()) } ,trait_type_id,JaktInternal::OptionalNone(),JaktInternal::OptionalNone())))));
+types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(synthetic_struct_id)))))));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(num_match_errors)});
+JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((parsed_trait).methods)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t error_index = (_magic_value.value());
+parser::ParsedFunction parsed_function = (_magic_value.value());
 {
-TRY((((argument_errors).push((((((((*this).compiler))->errors)).pop()).value())))));
-}
-
+types::ScopeId const method_scope_id = TRY((((*this).create_scope(trait_scope_id,((parsed_function).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("trait-method({}::{})"sv),((parsed_trait).name),((parsed_function).name)))),true))));
+types::FunctionId const function_id = ((((((*this).program))->get_module(((*this).current_module_id))))->next_function_id());
+JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
+if (((!(((((parsed_function).params)).is_empty()))) && ((((((((((parsed_function).params)).first()).value())).variable)).name) == Jakt::DeprecatedString("this"sv)))){
+(this_arg_type_id = struct_type_id);
 }
+TRY((((*this).typecheck_function_predecl(parsed_function,trait_scope_id,this_arg_type_id,JaktInternal::OptionalNone()))));
+TRY((((((checked_trait)->methods)).set(((parsed_function).name),function_id))));
 }
 
-return ( typechecker::FunctionMatchResult { typename typechecker::FunctionMatchResult::MatchError(argument_errors) } );
-}
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const used_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-return ( typechecker::FunctionMatchResult { typename typechecker::FunctionMatchResult::MatchSuccess(args,maybe_this_type_id,used_inferences,total_function_specificity) } );
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::dump_type_hint(types::TypeId const type_id,utility::Span const span) const {
-{
-outln(Jakt::DeprecatedString("{{\"type\":\"hint\",\"file_id\":{},\"position\":{},\"typename\":\"{}\"}}"sv),((((span).file_id)).id),((span).end),TRY((((*this).type_name(type_id,false)))));
 }
 return {};
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_namespace_default_fields(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
+ErrorOr<bool> typechecker::Typechecker::implements_trait(types::TypeId const type_id,types::TraitId const trait_id,JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const generic_arguments) {
 {
-JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
+Function<ErrorOr<bool>(JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>, types::TraitId, JaktInternal::DynamicArray<types::TypeId>, typechecker::Typechecker&)> const has_matching_trait = [type_id](JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> trait_implementations, types::TraitId trait_id, JaktInternal::DynamicArray<types::TypeId> passed_generic_arguments, typechecker::Typechecker& typechecker) -> ErrorOr<bool> {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
+bool const old_ignore_errors = ((((typechecker))).ignore_errors);
+(((((typechecker))).ignore_errors) = true);
+ScopeGuard __jakt_var_480([&] {
 {
-parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
-types::ScopeId const child_namespace_scope_id = ((children)[i]);
-TRY((((*this).typecheck_namespace_default_fields(child_namespace,child_namespace_scope_id))));
-}
-
-}
+(((((typechecker))).ignore_errors) = old_ignore_errors);
+(((((typechecker))).had_an_error) = false);
 }
 
+});
+bool found = false;
 {
-JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+JaktInternal::ArrayIterator<JaktInternal::DynamicArray<types::TypeId>> _magic = ((trait_implementations).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedRecord record = (_magic_value.value());
+JaktInternal::DynamicArray<types::TypeId> implemented_generic_arguments = (_magic_value.value());
 {
-if ((((((record).record_type)).index() == 0 /* Struct */) || ((((record).record_type)).index() == 1 /* Class */))){
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
-if ((!(((struct_id).has_value())))){
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find previously added struct"sv)))));
-}
-TRY((((*this).typecheck_struct_default_fields(record,(struct_id.value()),scope_id))));
-}
-}
-
-}
-}
-
-}
-return {};
+if ((((implemented_generic_arguments).size()) != ((passed_generic_arguments).size()))){
+continue;
 }
-
-ErrorOr<void> typechecker::Typechecker::typecheck_namespace_imports(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
-{
+bool ok = false;
 {
-JaktInternal::ArrayIterator<parser::ParsedModuleImport> _magic = ((((parsed_namespace).module_imports)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((implemented_generic_arguments).size()))});
 for (;;){
-JaktInternal::Optional<parser::ParsedModuleImport> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedModuleImport module_import = (_magic_value.value());
+size_t i = (_magic_value.value());
 {
-TRY((((*this).typecheck_module_import(module_import,scope_id))));
+(ok = TRY((((((typechecker))).check_types_for_compat(((implemented_generic_arguments)[i]),((passed_generic_arguments)[i]),((((((typechecker))).generic_inferences))),utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)))))));
+if ((!(ok))){
+break;
+}
 }
 
 }
 }
 
-{
-JaktInternal::ArrayIterator<parser::ParsedExternImport> _magic = ((((parsed_namespace).extern_imports)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedExternImport> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if ((!(ok))){
+continue;
 }
-parser::ParsedExternImport extern_import = (_magic_value.value());
-{
-TRY((((*this).typecheck_extern_import(extern_import,scope_id))));
+(found = true);
+break;
 }
 
 }
 }
 
+return (found);
+}
+}
+;
+JaktInternal::DynamicArray<types::TypeId> const empty = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+return (TRY((has_matching_trait(TRY((((*this).find_all_implementations_of_trait(type_id,trait_id)))),trait_id,generic_arguments.value_or_lazy_evaluated([&] { return empty; }),((*this))))));
 }
-return {};
 }
 
-ErrorOr<types::TypeId> typechecker::Typechecker::typecheck_typename(NonnullRefPtr<typename parser::ParsedType> const parsed_type,types::ScopeId const scope_id,JaktInternal::Optional<DeprecatedString> const name) {
+ErrorOr<void> typechecker::Typechecker::typecheck_module_import(parser::ParsedModuleImport const import_,types::ScopeId const scope_id) {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<types::TypeId>>{
-auto&& __jakt_match_variant = *parsed_type;
+JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> const module_names_and_spans = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((import_).module_name);
 switch(__jakt_match_variant.index()) {
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Reference>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_501; {
-types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
-__jakt_var_501 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Reference>(inner_type_id))))))); goto __jakt_label_452;
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Literal>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>>((TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({(Tuple{name, span})}))))));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ImportName::Comptime>();NonnullRefPtr<typename parser::ParsedExpression> const& expression = __jakt_match_value.expression;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>> __jakt_var_481; {
+NonnullRefPtr<interpreter::Interpreter> interpreter = TRY((((*this).interpreter())));
+NonnullRefPtr<interpreter::InterpreterScope> eval_scope = TRY((interpreter::InterpreterScope::from_runtime_scope(scope_id,((*this).program),JaktInternal::OptionalNone())));
+types::ScopeId const exec_scope = TRY((((*this).create_scope(scope_id,true,Jakt::DeprecatedString("comptime-import"sv),true))));
+interpreter::StatementResult const result = TRY((((interpreter)->execute_expression(TRY((((*this).typecheck_expression(expression,exec_scope, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone())))),eval_scope))));
+__jakt_var_481 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>, ErrorOr<void>>{
+auto&& __jakt_match_variant = result;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_482; {
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((expression)->span())))));
+__jakt_var_482 = JaktInternal::OptionalNone(); goto __jakt_label_427;
 
 }
-__jakt_label_452:; __jakt_var_501.release_value(); }));
+__jakt_label_427:; __jakt_var_482; }));
 };/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::MutableReference>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_502; {
-types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
-__jakt_var_502 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::MutableReference>(inner_type_id))))))); goto __jakt_label_453;
+case 2: {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_483; {
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((expression)->span())))));
+__jakt_var_483 = JaktInternal::OptionalNone(); goto __jakt_label_428;
 
 }
-__jakt_label_453:; __jakt_var_502.release_value(); }));
+__jakt_label_428:; __jakt_var_483; }));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<DeprecatedString> const& namespaces = __jakt_match_value.namespaces;
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& params = __jakt_match_value.params;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_503; {
-types::ScopeId current_namespace_scope_id = scope_id;
-{
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((namespaces).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-DeprecatedString ns = (_magic_value.value());
-{
-JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const result = TRY((((*this).find_namespace_in_scope(current_namespace_scope_id,ns,false))));
-if (((result).has_value())){
-(current_namespace_scope_id = (((result.value())).template get<0>()));
-}
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown namespace: '{}'"sv),ns))),span))));
-return (types::unknown_type_id());
-}
+case 3: {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_484; {
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((expression)->span())))));
+__jakt_var_484 = JaktInternal::OptionalNone(); goto __jakt_label_429;
 
 }
+__jakt_label_429:; __jakt_var_484; }));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_485; {
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((expression)->span())))));
+__jakt_var_485 = JaktInternal::OptionalNone(); goto __jakt_label_430;
 
 }
-}
+__jakt_label_430:; __jakt_var_485; }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::Throw>();
+types::Value const& error = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_486; {
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),TRY((__jakt_format(Jakt::DeprecatedString("this expression threw an error: {}"sv),error))),((expression)->span())))));
+__jakt_var_486 = JaktInternal::OptionalNone(); goto __jakt_label_431;
 
-JaktInternal::DynamicArray<types::TypeId> generic_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((params).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+}
+__jakt_label_431:; __jakt_var_486; }));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename interpreter::StatementResult::JustValue>();
+types::Value const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>, ErrorOr<void>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& string = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>>((TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({(Tuple{string, ((value).span)})}))))));
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::ValueImpl::JaktArray>();JaktInternal::DynamicArray<types::Value> const& values = __jakt_match_value.values;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>> __jakt_var_487; {
+if (((values).is_empty())){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to an empty array"sv),((expression)->span())))));
+}
+JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>> result = (TRY((DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::Value> _magic = ((values).iterator());
+for (;;){
+JaktInternal::Optional<types::Value> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedType> param = (_magic_value.value());
+types::Value value = (_magic_value.value());
 {
-types::TypeId const checked_arg = TRY((((*this).typecheck_typename(param,scope_id,name))));
-TRY((((generic_args).push(checked_arg))));
-}
-
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = *((value).impl);
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::JaktString>();
+DeprecatedString const& string = __jakt_match_value.value;
+return (TRY((((result).push((Tuple{string, ((value).span)})))))), JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal or an array of strings"sv),((value).span),Jakt::DeprecatedString("this expression evaluates to an invalid value"sv),((value).span)))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
 
-JaktInternal::Optional<types::TypeId> type_id = JaktInternal::OptionalNone();
-if (((generic_args).is_empty())){
-NonnullRefPtr<typename parser::ParsedType> const synthetic_typename = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Name>(name,span)));
-(type_id = TRY((((*this).typecheck_typename(synthetic_typename,current_namespace_scope_id,name)))));
 }
-else {
-(type_id = TRY((((*this).typecheck_generic_resolved_type(name,generic_args,current_namespace_scope_id,span)))));
 }
 
-__jakt_var_503 = (type_id.value()); goto __jakt_label_454;
+__jakt_var_487 = static_cast<JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>>>(result); goto __jakt_label_432;
 
 }
-__jakt_label_454:; __jakt_var_503.release_value(); }));
+__jakt_label_432:; __jakt_var_487.release_value(); }));
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& name = __jakt_match_value.name;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_504; {
-JaktInternal::Optional<JaktInternal::Tuple<types::TypeId,types::ScopeId>> const maybe_type_and_scope = TRY((((*this).find_type_scope(scope_id,name))));
-if (((maybe_type_and_scope).has_value())){
-if ((!((((((maybe_type_and_scope.value())).template get<1>())).equals(((*this).prelude_scope_id())))))){
-return ((((maybe_type_and_scope.value())).template get<0>()));
-}
-}
-__jakt_var_504 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId,ErrorOr<types::TypeId>>{
-auto __jakt_enum_value = (name);
-if (__jakt_enum_value == Jakt::DeprecatedString("i8"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } ));
+default: {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span>>> __jakt_var_488; {
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("module name must evalute to a string literal"sv),((expression)->span()),Jakt::DeprecatedString("this expression evaluates to a non-string value"sv),((expression)->span())))));
+__jakt_var_488 = JaktInternal::OptionalNone(); goto __jakt_label_433;
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("i16"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } ));
+__jakt_label_433:; __jakt_var_488; }));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_426;
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("i32"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } ));
+__jakt_label_426:; __jakt_var_481.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+if ((!(((module_names_and_spans).has_value())))){
+return {};
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("i64"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } ));
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>> module_name_and_span = JaktInternal::OptionalNone();
+JaktInternal::DynamicArray<DeprecatedString> names = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<DeprecatedString,utility::Span>> _magic = (((module_names_and_spans.value())).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,utility::Span>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("u8"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } ));
+JaktInternal::Tuple<DeprecatedString,utility::Span> name_and_span = (_magic_value.value());
+{
+TRY((((names).push(((name_and_span).template get<0>())))));
+JaktInternal::Optional<types::LoadedModule> maybe_loaded_module = ((((*this).program))->get_loaded_module(((name_and_span).template get<0>())));
+if ((!(((maybe_loaded_module).has_value())))){
+JaktInternal::Optional<jakt__path::Path> const maybe_file_name = TRY((((((*this).compiler))->search_for_path(((name_and_span).template get<0>())))));
+jakt__path::Path const file_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<jakt__path::Path,ErrorOr<void>>{
+auto __jakt_enum_value = (((maybe_file_name).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue((maybe_file_name.value()));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("u16"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } ));
+else {
+return JaktInternal::ExplicitValue(TRY((((TRY((((TRY((((TRY((((*this).get_root_path())))).parent())))).join(((name_and_span).template get<0>())))))).replace_extension(Jakt::DeprecatedString("jakt"sv))))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("u32"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } ));
+}()))
+;
+if (File::exists(((file_name).to_string()))){
+(module_name_and_span = name_and_span);
+break;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("u64"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } ));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("f32"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::F32() } ));
+else {
+(module_name_and_span = name_and_span);
+break;
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("f64"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::F64() } ));
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("c_char"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } ));
+
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("c_int"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } ));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("usize"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } ));
+
+if ((!(((module_name_and_span).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("No module in module set {{{}}} was found"sv),utility::join(names,Jakt::DeprecatedString(", "sv))))),((((import_).module_name)).span())))));
+return {};
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("String"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+JaktInternal::Tuple<DeprecatedString,utility::Span> const module_name_module_span_ = (module_name_and_span.value());
+DeprecatedString const module_name = ((module_name_module_span_).template get<0>());
+utility::Span const module_span = ((module_name_module_span_).template get<1>());
+
+DeprecatedString const sanitized_module_name = ((module_name).replace(Jakt::DeprecatedString(":"sv),Jakt::DeprecatedString("_"sv)));
+types::ModuleId imported_module_id = types::ModuleId(static_cast<size_t>(0ULL));
+JaktInternal::Optional<types::LoadedModule> maybe_loaded_module = ((((*this).program))->get_loaded_module(sanitized_module_name));
+if ((!(((maybe_loaded_module).has_value())))){
+JaktInternal::Optional<jakt__path::Path> const maybe_file_name = TRY((((((*this).compiler))->search_for_path(module_name))));
+jakt__path::Path const file_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<jakt__path::Path,ErrorOr<void>>{
+auto __jakt_enum_value = (((maybe_file_name).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue((maybe_file_name.value()));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("bool"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
+else {
+return JaktInternal::ExplicitValue(TRY((((TRY((((TRY((((TRY((((*this).get_root_path())))).parent())))).join(module_name))))).replace_extension(Jakt::DeprecatedString("jakt"sv))))));
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("void"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } ));
+}()))
+;
+utility::FileId const file_id = TRY((((((*this).compiler))->get_file_id_or_register(file_name))));
+JaktInternal::Optional<parser::ParsedNamespace> const parsed_namespace = TRY((((*this).lex_and_parse_file_contents(file_id))));
+if ((!(((parsed_namespace).has_value())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Module '{}' not found"sv),module_name))),module_span))));
+return {};
 }
-else if (__jakt_enum_value == Jakt::DeprecatedString("never"sv)) {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Never() } ));
+types::ModuleId const original_current_module_id = ((*this).current_module_id);
+(imported_module_id = TRY((((*this).create_module(sanitized_module_name,false,((file_name).to_string()))))));
+TRY((((((*this).program))->set_loaded_module(sanitized_module_name,types::LoadedModule(imported_module_id,file_id)))));
+(((*this).current_module_id) = imported_module_id);
+types::ScopeId const imported_scope_id = TRY((((*this).create_scope(((*this).root_scope_id()),false,TRY((__jakt_format(Jakt::DeprecatedString("module({})"sv),sanitized_module_name))),false))));
+NonnullRefPtr<types::Scope> imported_scope = TRY((((*this).get_scope(imported_scope_id))));
+(((imported_scope)->namespace_name) = sanitized_module_name);
+TRY((((*this).typecheck_module((parsed_namespace.value()),imported_scope_id))));
+(((*this).current_module_id) = original_current_module_id);
 }
 else {
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_505; {
-if (((maybe_type_and_scope).has_value())){
-return ((((maybe_type_and_scope.value())).template get<0>()));
+(imported_module_id = (((maybe_loaded_module.value())).module_id));
 }
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type ‘{}’"sv),name))),span))));
-__jakt_var_505 = types::unknown_type_id(); goto __jakt_label_456;
 
+JaktInternal::DynamicArray<types::ModuleId> current_module_imports = ((((*this).current_module()))->imports);
+TRY((((current_module_imports).push(imported_module_id))));
+if (((((import_).import_list)).is_empty())){
+JaktInternal::Dictionary<DeprecatedString,types::ModuleId> scope_imports = ((TRY((((*this).get_scope(scope_id)))))->imports);
+DeprecatedString import_name = module_name;
+if (((((import_).alias_name)).has_value())){
+(import_name = (((((import_).alias_name).value())).literal_name()));
 }
-__jakt_label_456:; __jakt_var_505.release_value(); }));
+TRY((((scope_imports).set(import_name,imported_module_id))));
 }
-}()))
-; goto __jakt_label_455;
+else if (((((import_).import_list)).index() == 1 /* All */)){
+NonnullRefPtr<types::Scope> const import_scope = TRY((((*this).get_scope(types::ScopeId(imported_module_id,static_cast<size_t>(0ULL))))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::VarId> _magic = ((((import_scope)->vars)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::VarId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<DeprecatedString,types::VarId> name__var_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::VarId> const jakt__name__var_id__ = name__var_id__;
+DeprecatedString const name = ((jakt__name__var_id__).template get<0>());
+types::VarId const var_id = ((jakt__name__var_id__).template get<1>());
 
+TRY((((*this).add_var_to_scope(scope_id,name,var_id,((((import_).module_name)).span())))));
 }
-__jakt_label_455:; __jakt_var_504.release_value(); }));
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_506; {
-__jakt_var_506 = types::unknown_type_id(); goto __jakt_label_457;
 
 }
-__jakt_label_457:; __jakt_var_506.release_value(); }));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& types = __jakt_match_value.types;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_507; {
-JaktInternal::DynamicArray<types::TypeId> checked_types = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+}
+
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((types).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,types::Value> _magic = ((((import_scope)->comptime_bindings)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::Value>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedType> parsed_type = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::Value> name__value__ = (_magic_value.value());
 {
-TRY((((checked_types).push(TRY((((*this).typecheck_typename(parsed_type,scope_id,name))))))));
+JaktInternal::Tuple<DeprecatedString,types::Value> const jakt__name__value__ = name__value__;
+DeprecatedString const name = ((jakt__name__value__).template get<0>());
+types::Value const value = ((jakt__name__value__).template get<1>());
+
+TRY((((*this).add_comptime_binding_to_scope(scope_id,name,value,((((import_).module_name)).span())))));
 }
 
 }
 }
 
-types::StructId const tuple_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
-__jakt_var_507 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(tuple_struct_id,checked_types))))))); goto __jakt_label_458;
-
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::StructId> _magic = ((((import_scope)->structs)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::StructId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_458:; __jakt_var_507.release_value(); }));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktArray>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_508; {
-types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
-types::StructId const array_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
-__jakt_var_508 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id}))))))))))); goto __jakt_label_459;
+JaktInternal::Tuple<DeprecatedString,types::StructId> name__struct_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::StructId> const jakt__name__struct_id__ = name__struct_id__;
+DeprecatedString const name = ((jakt__name__struct_id__).template get<0>());
+types::StructId const struct_id = ((jakt__name__struct_id__).template get<1>());
 
+TRY((((*this).add_struct_to_scope(scope_id,name,struct_id,((((import_).module_name)).span())))));
 }
-__jakt_label_459:; __jakt_var_508.release_value(); }));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Dictionary>();NonnullRefPtr<typename parser::ParsedType> const& key = __jakt_match_value.key;
-NonnullRefPtr<typename parser::ParsedType> const& value = __jakt_match_value.value;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_509; {
-types::TypeId const key_type_id = TRY((((*this).typecheck_typename(key,scope_id,name))));
-types::TypeId const value_type_id = TRY((((*this).typecheck_typename(value,scope_id,name))));
-types::StructId const dict_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
-__jakt_var_509 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(dict_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({key_type_id, value_type_id}))))))))))); goto __jakt_label_460;
 
 }
-__jakt_label_460:; __jakt_var_509.release_value(); }));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Set>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_510; {
-types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
-types::StructId const set_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Set"sv)))));
-__jakt_var_510 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(set_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id}))))))))))); goto __jakt_label_461;
-
 }
-__jakt_label_461:; __jakt_var_510.release_value(); }));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Optional>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_511; {
-types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-__jakt_var_511 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id}))))))))))); goto __jakt_label_462;
 
+{
+JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((import_scope)->functions)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_462:; __jakt_var_511.release_value(); }));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::WeakPtr>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_512; {
-types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
-types::StructId const weakptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-__jakt_var_512 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(weakptr_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id}))))))))))); goto __jakt_label_463;
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> name__overload_set__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt__name__overload_set__ = name__overload_set__;
+DeprecatedString const name = ((jakt__name__overload_set__).template get<0>());
+JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt__name__overload_set__).template get<1>());
 
+TRY((((*this).add_function_to_scope(scope_id,name,overload_set,((((import_).module_name)).span())))));
 }
-__jakt_label_463:; __jakt_var_512.release_value(); }));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::RawPtr>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_513; {
-types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
-__jakt_var_513 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::RawPtr>(inner_type_id))))))); goto __jakt_label_464;
 
 }
-__jakt_label_464:; __jakt_var_513.release_value(); }));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::GenericType>();DeprecatedString const& name = __jakt_match_value.name;
-JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& generic_parameters = __jakt_match_value.generic_parameters;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_514; {
-JaktInternal::DynamicArray<types::TypeId> checked_inner_types = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+}
+
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((generic_parameters).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,types::EnumId> _magic = ((((import_scope)->enums)).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::EnumId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedType> inner_type = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::EnumId> name__enum_id__ = (_magic_value.value());
 {
-types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner_type,scope_id,name))));
-TRY((((checked_inner_types).push(inner_type_id))));
+JaktInternal::Tuple<DeprecatedString,types::EnumId> const jakt__name__enum_id__ = name__enum_id__;
+DeprecatedString const name = ((jakt__name__enum_id__).template get<0>());
+types::EnumId const enum_id = ((jakt__name__enum_id__).template get<1>());
+
+TRY((((*this).add_enum_to_scope(scope_id,name,enum_id,((((import_).module_name)).span())))));
 }
 
 }
 }
 
-__jakt_var_514 = TRY((((*this).typecheck_generic_resolved_type(name,checked_inner_types,scope_id,span)))); goto __jakt_label_465;
-
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::TypeId> _magic = ((((import_scope)->types)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::TypeId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-__jakt_label_465:; __jakt_var_514.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Function>();JaktInternal::DynamicArray<parser::ParsedParameter> const& params = __jakt_match_value.params;
-bool const& can_throw = __jakt_match_value.can_throw;
-NonnullRefPtr<typename parser::ParsedType> const& return_type = __jakt_match_value.return_type;
-utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_515; {
-DeprecatedString const function_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<types::TypeId>>{
-auto __jakt_enum_value = (((name).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue((name.value()));
+JaktInternal::Tuple<DeprecatedString,types::TypeId> name__type_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::TypeId> const jakt__name__type_id__ = name__type_id__;
+DeprecatedString const name = ((jakt__name__type_id__).template get<0>());
+types::TypeId const type_id = ((jakt__name__type_id__).template get<1>());
+
+TRY((((*this).add_type_to_scope(scope_id,name,type_id,((((import_).module_name)).span())))));
 }
-else {
-return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_516;
-auto __jakt_var_517 = [&]() -> ErrorOr<DeprecatedString> { return TRY((__jakt_format(Jakt::DeprecatedString("lambda{}"sv),((((*this).lambda_count)++))))); }();
-if (!__jakt_var_517.is_error()) __jakt_var_516 = __jakt_var_517.release_value();
-__jakt_var_516; }).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }));
+
 }
-}()))
-;
-JaktInternal::DynamicArray<types::CheckedParameter> checked_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
-bool first = true;
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-ScopeGuard __jakt_var_518([&] {
-{
-((((*this).generic_inferences)).restore(old_generic_inferences));
 }
 
-});
 {
-JaktInternal::ArrayIterator<parser::ParsedParameter> _magic = ((params).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,types::TraitId> _magic = ((((import_scope)->traits)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::TraitId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedParameter param = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::TraitId> name__trait_id__ = (_magic_value.value());
 {
-TRY((((checked_params).push(TRY((((*this).typecheck_parameter(param,scope_id,first,JaktInternal::OptionalNone(),JaktInternal::OptionalNone()))))))));
-(first = false);
+JaktInternal::Tuple<DeprecatedString,types::TraitId> const jakt__name__trait_id__ = name__trait_id__;
+DeprecatedString const name = ((jakt__name__trait_id__).template get<0>());
+types::TraitId const trait_id = ((jakt__name__trait_id__).template get<1>());
+
+TRY((((*this).add_trait_to_scope(scope_id,name,trait_id,((((import_).module_name)).span())))));
 }
 
 }
 }
 
-NonnullRefPtr<types::CheckedFunction> const checked_function = TRY((types::CheckedFunction::__jakt_create(function_name,span, types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,TRY((((*this).typecheck_typename(return_type,scope_id,JaktInternal::OptionalNone())))),((return_type)->span()),checked_params,TRY((types::FunctionGenerics::__jakt_create(scope_id,checked_params,(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,JaktInternal::OptionalNone(),false),can_throw, parser::FunctionType { typename parser::FunctionType::Expression() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,scope_id,JaktInternal::OptionalNone(),true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
-JaktInternal::DynamicArray<types::TypeId> param_type_ids = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+}
+else if (((((import_).import_list)).index() == 0 /* List */)){
+JaktInternal::DynamicArray<parser::ImportName> const names = ((((import_).import_list)).get<parser::ImportList::List>()).value;
+types::ScopeId const import_scope_id = types::ScopeId(imported_module_id,static_cast<size_t>(0ULL));
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((checked_function)->params)).iterator());
+JaktInternal::ArrayIterator<parser::ImportName> _magic = ((names).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ImportName> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+parser::ImportName imported_name = (_magic_value.value());
 {
-TRY((((param_type_ids).push(((((param).variable))->type_id)))));
+bool const found = TRY((((*this).find_and_import_name_from_scope(((imported_name).literal_name()),((imported_name).span()),((imported_name).literal_name()),((imported_name).span()),import_scope_id,scope_id,typechecker::ImportRestrictions::all()))));
+if ((!(found))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Imported name '{}' not found in module '{}'"sv),((imported_name).literal_name()),module_name))),((imported_name).span())))));
+}
 }
 
 }
 }
 
-__jakt_var_515 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Function>(param_type_ids,can_throw,((checked_function)->return_type_id),function_id))))))); goto __jakt_label_466;
+}
+}
+return {};
+}
 
+ErrorOr<JaktInternal::Optional<types::FunctionId>> typechecker::Typechecker::typecheck_method(parser::ParsedFunction const func,types::StructLikeId const parent_id) {
+{
+JaktInternal::DynamicArray<types::CheckedGenericParameter> parent_generic_parameters = (TRY((DynamicArray<types::CheckedGenericParameter>::create_with({}))));
+types::ScopeId parent_scope_id = ((*this).prelude_scope_id());
+parser::DefinitionLinkage parent_definition_linkage =  parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } ;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Optional<types::FunctionId>>>{
+auto&& __jakt_match_variant = parent_id;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+{
+types::CheckedStruct structure = ((*this).get_struct(struct_id));
+(parent_scope_id = ((structure).scope_id));
+(parent_definition_linkage = ((structure).definition_linkage));
+(parent_generic_parameters = ((structure).generic_parameters));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+{
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+(parent_scope_id = ((enum_).scope_id));
+(parent_definition_linkage = ((enum_).definition_linkage));
+(parent_generic_parameters = ((enum_).generic_parameters));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Trait>();
+types::TraitId const& trait_id = __jakt_match_value.value;
+{
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait(trait_id));
+(parent_scope_id = ((trait_)->scope_id));
+(parent_definition_linkage =  parser::DefinitionLinkage { typename parser::DefinitionLinkage::Internal() } );
+(parent_generic_parameters = ((trait_)->generic_parameters));
 }
-__jakt_label_466:; __jakt_var_515.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-)));
+));
+if ((((!(((((func).generic_parameters)).is_empty()))) || (!(((parent_generic_parameters).is_empty())))) && (!(((func).must_instantiate))))){
+return (JaktInternal::OptionalNone());
+}
+JaktInternal::Optional<types::FunctionId> const method_id = TRY((((*this).find_function_matching_signature_in_scope(parent_scope_id,func))));
+if (((method_id).has_value())){
+TRY((((*this).typecheck_function(func,parent_scope_id))));
+return ((method_id.value()));
+}
+else {
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("Previously defined function {} not found in scope {}"sv),((func).name),parent_scope_id)))))));
+}
+
 }
 }
 
-ErrorOr<JaktInternal::Optional<types::TypeId>> typechecker::Typechecker::unify(types::TypeId const lhs,utility::Span const lhs_span,types::TypeId const rhs,utility::Span const rhs_span) {
+ErrorOr<void> typechecker::Typechecker::typecheck_extern_import(parser::ParsedExternImport const import_,types::ScopeId const scope_id) {
 {
-if ((!(TRY((((*this).check_types_for_compat(lhs,rhs,((((*this).generic_inferences))),lhs_span))))))){
-return (JaktInternal::OptionalNone());
+{
+JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((((import_).assigned_namespace)).functions)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return (TRY((((*this).substitute_typevars_in_type(lhs,((*this).generic_inferences))))));
+parser::ParsedFunction f = (_magic_value.value());
+{
+if ((!(((((f).linkage)).index() == 1 /* External */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected all functions in an `import extern` to be be external"sv),((f).name_span)))));
+}
+if ((((import_).is_c) && (!(((((f).generic_parameters)).is_empty()))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("imported function '{}' is declared to have C linkage, but is generic"sv),((f).name)))),((f).name_span),Jakt::DeprecatedString("this function may not be generic"sv),((f).name_span)))));
+}
+if ((!(((((((f).block)).stmts)).is_empty())))){
+TRY((((*this).error(Jakt::DeprecatedString("imported extern function is not allowed to have a body"sv),((f).name_span)))));
 }
 }
 
-bool typechecker::Typechecker::is_numeric(types::TypeId const type_id) const {
-{
-return (((((*this).program))->is_numeric(type_id)));
 }
 }
 
-ErrorOr<bool> typechecker::Typechecker::add_type_to_scope(types::ScopeId const scope_id,DeprecatedString const type_name,types::TypeId const type_id,utility::Span const span) {
 {
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::TypeId> const found_type_id = ((((scope)->types)).get(type_name));
-if ((((found_type_id).has_value()) && (!((((found_type_id.value())).equals(type_id)))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of type ‘{}’"sv),type_name))),span))));
-return (false);
+JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((((import_).assigned_namespace)).records)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-TRY((((((scope)->types)).set(type_name,type_id))));
-return (true);
+parser::ParsedRecord record = (_magic_value.value());
+{
+if ((!(((((record).definition_linkage)).index() == 1 /* External */)))){
+TRY((((*this).error(Jakt::DeprecatedString("Expected all records in an `import extern` to be external"sv),((record).name_span)))));
+}
+if ((((import_).is_c) && (!(((((record).generic_parameters)).is_empty()))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("imported {} '{}' is declared to have C linkage, but is generic"sv),((((record).record_type)).record_type_name()),((record).name)))),((record).name_span),TRY((__jakt_format(Jakt::DeprecatedString("this {} may not be generic"sv),((((record).record_type)).record_type_name())))),((record).name_span)))));
 }
 }
 
-ErrorOr<bool> typechecker::Typechecker::add_var_to_scope(types::ScopeId const scope_id,DeprecatedString const name,types::VarId const var_id,utility::Span const span) {
-{
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::VarId> const existing_var = ((((scope)->vars)).get(name));
-if (((existing_var).has_value())){
-NonnullRefPtr<types::CheckedVariable> const variable_ = ((*this).get_variable((existing_var.value())));
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of variable ‘{}’"sv),name))),span,Jakt::DeprecatedString("previous definition here"sv),((variable_)->definition_span)))));
 }
-TRY((((((scope)->vars)).set(name,var_id))));
-TRY((((*this).set_owner_scope_if_needed(scope_id,var_id))));
-return (true);
 }
+
+}
+return {};
 }
 
-ErrorOr<JaktInternal::Optional<types::ScopeId>> typechecker::Typechecker::required_scope_id_in_hierarchy_for(NonnullRefPtr<typename types::CheckedExpression> const expr,types::ScopeId const current_scope_id) {
+types::BlockControlFlow typechecker::Typechecker::statement_control_flow(NonnullRefPtr<typename types::CheckedStatement> const statement) const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>, ErrorOr<JaktInternal::Optional<types::ScopeId>>>{
-auto&& __jakt_match_variant = *expr;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = *statement;
 switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+case 8: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+case 11: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+case 9: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(true) } );
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+case 10: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(false) } );
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((((expr)->control_flow())).updated( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(false) } )));
 };/*case end*/
 case 4: {
-return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& then_block = __jakt_match_value.then_block;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = *condition;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();bool const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
+auto __jakt_enum_value = (val);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((then_block).control_flow));
+}
+else {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
+auto __jakt_enum_value = (((else_statement).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(((*this).statement_control_flow((else_statement.value()))));
+}
+else {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+}
+}()))
+);
+}
+}()))
+);
 };/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+default: {
+return JaktInternal::ExplicitValue(((((then_block).control_flow)).branch_unify_with(((*this).maybe_statement_control_flow(else_statement,((then_block).control_flow))))));
 };/*case end*/
-case 33: {
-return JaktInternal::ExplicitValue(((*this).root_scope_id()));
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(((block).control_flow));
 };/*case end*/
 case 7: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
+types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = *condition;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();bool const& val = __jakt_match_value.val;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
+auto __jakt_enum_value = (val);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = ((block).control_flow);
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+}/*switch end*/
+}()
+)));
+}
+else {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+}
+}()))
+);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+}/*switch end*/
+}()
+)));
 };/*case end*/
 case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();types::CheckedUnaryOperator const& op = __jakt_match_value.op;
-NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>, ErrorOr<JaktInternal::Optional<types::ScopeId>>>{
-auto&& __jakt_match_variant = op;
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = ((block).control_flow);
 switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
+auto __jakt_enum_value = (might_break);
+if (__jakt_enum_value == false) {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+}
+else {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+}
+}()))
+);
 };/*case end*/
 case 2: {
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
 };/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+case 0: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
 };/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
+default: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
+auto __jakt_enum_value = (((((block).control_flow)).may_break()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+}
+else {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = ((block).control_flow);
+switch(__jakt_match_variant.index()) {
+case 4: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
 };/*case end*/
 }/*switch end*/
 }()
 )));
+}
+}()))
+);
 };/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_519; {
-JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->control_flow()));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
-NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
-{
-(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,TRY((((*this).required_scope_id_in_hierarchy_for(val,current_scope_id)))))))));
 }
 
+ErrorOr<JaktInternal::Optional<types::StructId>> typechecker::Typechecker::find_struct_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
+{
+return (TRY((((((*this).program))->find_struct_in_scope(scope_id,name)))));
 }
 }
 
-__jakt_var_519 = final_scope_id; goto __jakt_label_467;
-
+ErrorOr<JaktInternal::Optional<parser::ParsedNamespace>> typechecker::Typechecker::lex_and_parse_file_contents(utility::FileId const file_id) {
+{
+JaktInternal::Tuple<JaktInternal::Optional<utility::FileId>,JaktInternal::DynamicArray<u8>> const old_file_state = ((((*this).compiler))->current_file_state());
+if ((!(((((*this).compiler))->set_current_file(file_id))))){
+return (JaktInternal::OptionalNone());
 }
-__jakt_label_467:; __jakt_var_519.release_value(); }));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_520; {
-JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
+ScopeGuard __jakt_var_489([&] {
+((((*this).compiler))->restore_file_state(old_file_state));
+});
+JaktInternal::DynamicArray<lexer::Token> const tokens = TRY((lexer::Lexer::lex(((*this).compiler))));
+if (((((*this).compiler))->dump_lexer)){
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
+JaktInternal::ArrayIterator<lexer::Token> _magic = ((tokens).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<lexer::Token> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
+lexer::Token token = (_magic_value.value());
 {
-(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,TRY((((*this).required_scope_id_in_hierarchy_for(val,current_scope_id)))))))));
+outln(Jakt::DeprecatedString("token: {}"sv),token);
 }
 
 }
 }
 
-__jakt_var_520 = final_scope_id; goto __jakt_label_468;
-
-}
-__jakt_label_468:; __jakt_var_520.release_value(); }));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_521; {
-JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
-{
-(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,TRY((((*this).required_scope_id_in_hierarchy_for(val,current_scope_id)))))))));
+parser::ParsedNamespace const parsed_namespace = TRY((parser::Parser::parse(((*this).compiler),tokens)));
+if (((((*this).compiler))->dump_parser)){
+outln(Jakt::DeprecatedString("{:#}"sv),parsed_namespace);
 }
-
+return (parsed_namespace);
 }
 }
 
-__jakt_var_521 = final_scope_id; goto __jakt_label_469;
-
-}
-__jakt_label_469:; __jakt_var_521.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_522; {
-JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
+ErrorOr<void> typechecker::Typechecker::check_that_type_doesnt_contain_reference(types::TypeId const type_id,utility::Span const span) {
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (TRY((((*this).type_contains_reference(type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Reference type ‘{}’ not usable in this context"sv),TRY((((*this).type_name(type_id,false))))))),span))));
 }
-JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> key__val__ = (_magic_value.value());
-{
-JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> const jakt__key__val__ = key__val__;
-NonnullRefPtr<typename types::CheckedExpression> const key = ((jakt__key__val__).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const val = ((jakt__key__val__).template get<1>());
-
-(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,TRY((((*this).scope_lifetime_union(TRY((((*this).required_scope_id_in_hierarchy_for(key,current_scope_id)))),TRY((((*this).required_scope_id_in_hierarchy_for(val,current_scope_id)))))))))))));
+}
+return {};
 }
 
+ErrorOr<bool> typechecker::Typechecker::find_and_import_name_from_scope(DeprecatedString const from_name,utility::Span const from_span,DeprecatedString const to_name,utility::Span const to_span,types::ScopeId const from_scope_id,types::ScopeId const into_scope_id,typechecker::ImportRestrictions const allow) {
+{
+bool found = false;
+if (((allow).functions)){
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_overload_set = TRY((((*this).find_functions_with_name_in_scope(from_scope_id,from_name))));
+if (((maybe_overload_set).has_value())){
+(found = true);
+TRY((((*this).add_function_to_scope(into_scope_id,to_name,(maybe_overload_set.value()),to_span))));
 }
 }
-
-__jakt_var_522 = final_scope_id; goto __jakt_label_470;
-
+if (((allow).enums)){
+JaktInternal::Optional<types::EnumId> const maybe_enum_id = TRY((((((*this).program))->find_enum_in_scope(from_scope_id,from_name))));
+if (((maybe_enum_id).has_value())){
+(found = true);
+TRY((((*this).add_enum_to_scope(into_scope_id,to_name,(maybe_enum_id.value()),to_span))));
 }
-__jakt_label_470:; __jakt_var_522.release_value(); }));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
-};/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
-};/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ComptimeIndex>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
-};/*case end*/
-case 19: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 20: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 21: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
-return JaktInternal::ExplicitValue(((var)->owner_scope).value_or_lazy_evaluated([&] { return current_scope_id; }));
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NamespacedVar>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
-return JaktInternal::ExplicitValue(((var)->owner_scope).value_or_lazy_evaluated([&] { return current_scope_id; }));
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 26: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(TRY((((*this).required_scope_id_in_hierarchy_for(expr,current_scope_id)))));
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Function>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_523; {
-JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
-{
-JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedCapture capture = (_magic_value.value());
-{
-JaktInternal::Optional<types::ScopeId> scope_id = JaktInternal::OptionalNone();
-if ((((capture).index() == 2 /* ByMutableReference */) || ((capture).index() == 1 /* ByReference */))){
-JaktInternal::Optional<JaktInternal::Optional<types::ScopeId>> const scope_id = ((TRY((((*this).find_var_in_scope(current_scope_id,((capture).name())))))).map([](auto& _value) { return _value->owner_scope; }));
-}
-(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,scope_id)))));
-}
-
 }
+if (((allow).types)){
+JaktInternal::Optional<types::TypeId> const maybe_type_id = TRY((((*this).find_type_in_scope(from_scope_id,from_name))));
+if (((maybe_type_id).has_value())){
+(found = true);
+TRY((((*this).add_type_to_scope(into_scope_id,to_name,(maybe_type_id.value()),to_span))));
 }
-
-__jakt_var_523 = final_scope_id; goto __jakt_label_471;
-
 }
-__jakt_label_471:; __jakt_var_523.release_value(); }));
-};/*case end*/
-case 30: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::DependentFunction>();JaktInternal::DynamicArray<types::CheckedCapture> const& captures = __jakt_match_value.captures;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::ScopeId>> __jakt_var_524; {
-JaktInternal::Optional<types::ScopeId> final_scope_id = JaktInternal::OptionalNone();
-{
-JaktInternal::ArrayIterator<types::CheckedCapture> _magic = ((captures).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedCapture> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((allow).structs)){
+JaktInternal::Optional<types::StructId> const maybe_struct_id = TRY((((*this).find_struct_in_scope(from_scope_id,from_name))));
+if (((maybe_struct_id).has_value())){
+(found = true);
+TRY((((*this).add_struct_to_scope(into_scope_id,to_name,(maybe_struct_id.value()),to_span))));
 }
-types::CheckedCapture capture = (_magic_value.value());
-{
-JaktInternal::Optional<types::ScopeId> scope_id = JaktInternal::OptionalNone();
-if ((((capture).index() == 2 /* ByMutableReference */) || ((capture).index() == 1 /* ByReference */))){
-JaktInternal::Optional<JaktInternal::Optional<types::ScopeId>> const scope_id = ((TRY((((*this).find_var_in_scope(current_scope_id,((capture).name())))))).map([](auto& _value) { return _value->owner_scope; }));
 }
-(final_scope_id = TRY((((*this).scope_lifetime_union(final_scope_id,scope_id)))));
+if (((allow).traits)){
+JaktInternal::Optional<types::TraitId> const maybe_trait_id = TRY((((*this).find_trait_in_scope(from_scope_id,from_name))));
+if (((maybe_trait_id).has_value())){
+(found = true);
+TRY((((*this).add_trait_to_scope(into_scope_id,to_name,(maybe_trait_id.value()),to_span))));
 }
-
 }
+if (((allow).namespaces)){
+JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const maybe_scope_id = TRY((((*this).find_namespace_in_scope(from_scope_id,from_name,false))));
+if (((maybe_scope_id).has_value())){
+(found = true);
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(into_scope_id))));
+TRY((((((scope)->aliases)).set(to_name,(((maybe_scope_id.value())).template get<0>())))));
 }
-
-__jakt_var_524 = final_scope_id; goto __jakt_label_472;
-
 }
-__jakt_label_472:; __jakt_var_524.release_value(); }));
-};/*case end*/
-case 31: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 32: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-case 34: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+return (found);
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_try(NonnullRefPtr<typename parser::ParsedExpression> const expr,JaktInternal::Optional<parser::ParsedBlock> const catch_block,JaktInternal::Optional<DeprecatedString> const catch_name,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span,JaktInternal::Optional<types::TypeId> const type_hint) {
+ErrorOr<bool> typechecker::Typechecker::validate_argument_label(types::CheckedParameter const param,DeprecatedString const label,utility::Span const span,NonnullRefPtr<typename parser::ParsedExpression> const expr,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const default_value) {
 {
-types::ScopeId const try_scope_id = TRY((((*this).create_scope(scope_id,true,Jakt::DeprecatedString("try"sv),true))));
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression(expr,try_scope_id,safety_mode,type_hint))));
-types::StructId const error_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-JaktInternal::Optional<types::CheckedBlock> checked_catch_block = JaktInternal::OptionalNone();
-types::TypeId const expression_type_id = ((checked_expr)->type());
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-NonnullRefPtr<typename types::Type> const optional_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({expression_type_id})))))));
-types::TypeId const optional_type_id = TRY((((*this).find_or_add_type_id(optional_type))));
-types::TypeId type_id = optional_type_id;
-if (((catch_block).has_value())){
-NonnullRefPtr<types::Scope> const parent_scope = TRY((((*this).get_scope(scope_id))));
-types::ScopeId const catch_scope_id = TRY((((*this).create_scope(scope_id,((parent_scope)->can_throw),Jakt::DeprecatedString("catch"sv),true))));
-if (((catch_name).has_value())){
-types::StructId const error_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
-NonnullRefPtr<types::CheckedVariable> const error_decl = TRY((types::CheckedVariable::__jakt_create((catch_name.value()),((((*this).get_struct(error_struct_id))).type_id),false,span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::VarId const error_id = TRY((((module)->add_variable(error_decl))));
-TRY((((*this).add_var_to_scope(catch_scope_id,(catch_name.value()),error_id,span))));
+DeprecatedString const name = ((*this).get_argument_name((Tuple{label, span, expr})));
+if ((name == ((((param).variable))->name))){
+return (true);
 }
-types::CheckedBlock const block = TRY((((*this).typecheck_block((catch_block.value()),catch_scope_id,safety_mode,JaktInternal::OptionalNone()))));
-if ((((((block).control_flow)).always_transfers_control()) || ((((block).yielded_type)).has_value()))){
-if ((!(((((block).yielded_type).value_or_lazy_evaluated([&] { return expression_type_id; })).equals(expression_type_id))))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Expected a value of type ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(expression_type_id,false)))),TRY((((*this).type_name((((block).yielded_type).value()),false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("Expression 'catch' block must either yield the same type as the expression it is catching, or yield nothing"sv)))),span))));
+if ((!(((default_value).has_value())))){
+if (((label).is_empty())){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Missing argument label (expected '{}:')"sv),((((param).variable))->name)))),((expr)->span())))));
 }
 else {
-(type_id = ((block).yielded_type).value_or_lazy_evaluated([&] { return expression_type_id; }));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Wrong parameter name in argument label (got '{}', expected '{}')"sv),label,((((param).variable))->name)))),span))));
 }
 
 }
-else {
-if ((!(((expression_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } )))))){
-TRY((((*this).error(Jakt::DeprecatedString("In a try expression that returns a value, 'catch' block must either yield a value or transfer control flow"sv),span))));
+return (false);
 }
 }
 
-(checked_catch_block = block);
+ErrorOr<bool> typechecker::Typechecker::add_enum_to_scope(types::ScopeId const scope_id,DeprecatedString const name,types::EnumId const enum_id,utility::Span const span) {
+{
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::EnumId> const maybe_enum_id = ((((scope)->enums)).get(name));
+if (((maybe_enum_id).has_value())){
+types::EnumId const existing_enum_id = (maybe_enum_id.value());
+utility::Span const definition_span = ((((*this).get_enum(existing_enum_id))).name_span);
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("redefinition of enum {}"sv),name))),span,TRY((__jakt_format(Jakt::DeprecatedString("enum {} was first defined here"sv),name))),definition_span))));
+return (false);
 }
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Try>(checked_expr,checked_catch_block,catch_name,span,type_id,expression_type_id))));
+TRY((((((scope)->enums)).set(name,enum_id))));
+return (true);
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::include_prelude() {
+ErrorOr<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>>> typechecker::Typechecker::expand_context_for_bindings(NonnullRefPtr<typename parser::ParsedExpression> const condition,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const acc,JaktInternal::Optional<parser::ParsedBlock> const then_block,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const else_statement,utility::Span const span) {
 {
-DeprecatedString const module_name = Jakt::DeprecatedString("__prelude__"sv);
-jakt__path::Path const file_name = TRY((jakt__path::Path::from_string(module_name)));
-JaktInternal::DynamicArray<u8> const file_contents = (TRY((DynamicArray<u8>::create_with({static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(79), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(79), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(60), static_cast<u8>(83), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(79), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(60), static_cast<u8>(83), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(68), static_cast<u8>(121), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(107), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(100), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(95), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(111), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(38), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(112), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(97), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(100), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(83), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(97), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(100), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(67), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(80), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(80), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(101), static_cast<u8>(107), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(121), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(111), static_cast<u8>(102), static_cast<u8>(102), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(80), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(95), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(102), static_cast<u8>(56), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(121), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(98), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(98), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(117), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(119), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(121), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(119), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(119), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(119), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(66), static_cast<u8>(117), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(66), static_cast<u8>(117), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(95), static_cast<u8>(106), static_cast<u8>(115), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(66), static_cast<u8>(117), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(112), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(65), static_cast<u8>(80), static_cast<u8>(73), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(87), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(80), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(117), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(40), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(75), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(75), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(111), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(75), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(121), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(75), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(65), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(66), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(60), static_cast<u8>(65), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(66), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(68), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(121), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(75), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(60), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(109), static_cast<u8>(111), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(60), static_cast<u8>(65), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(60), static_cast<u8>(65), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(73), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(86), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(85), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(85), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(63), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(34), static_cast<u8>(111), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(91), static_cast<u8>(93), static_cast<u8>(34), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(121), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(69), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(95), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(119), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(69), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(61), static_cast<u8>(34), static_cast<u8>(95), static_cast<u8>(95), static_cast<u8>(106), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(95), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(34), static_cast<u8>(93), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(95), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(119), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(69), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(111), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(95), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(111), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(95), static_cast<u8>(119), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(117), static_cast<u8>(102), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(119), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(100), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(108), static_cast<u8>(40), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(95), static_cast<u8>(95), static_cast<u8>(95), static_cast<u8>(106), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(112), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(60), static_cast<u8>(85), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(60), static_cast<u8>(85), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(112), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(97), static_cast<u8>(100), static_cast<u8>(100), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(115), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(108), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(101), static_cast<u8>(120), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(100), static_cast<u8>(105), static_cast<u8>(118), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(45), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(80), static_cast<u8>(117), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(80), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(119), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(68), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(60), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(62), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(32), static_cast<u8>(46), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(91), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(93), static_cast<u8>(40), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(38), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(73), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(115), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(95), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(77), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(70), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(86), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(98), static_cast<u8>(105), static_cast<u8>(108), static_cast<u8>(105), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(111), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(80), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(112), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(111), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(66), static_cast<u8>(108), static_cast<u8>(111), static_cast<u8>(99), static_cast<u8>(107), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(110), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(99), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(109), static_cast<u8>(112), static_cast<u8>(116), static_cast<u8>(105), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(76), static_cast<u8>(105), static_cast<u8>(107), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(108), static_cast<u8>(97), static_cast<u8>(115), static_cast<u8>(115), static_cast<u8>(40), static_cast<u8>(102), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(70), static_cast<u8>(105), static_cast<u8>(101), static_cast<u8>(108), static_cast<u8>(100), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(47), static_cast<u8>(47), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(40), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(100), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(108), static_cast<u8>(121), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(108), static_cast<u8>(117), static_cast<u8>(101), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(93), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(40), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(95), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(120), static_cast<u8>(101), static_cast<u8>(100), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(118), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(83), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(77), static_cast<u8>(101), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(111), static_cast<u8>(100), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(103), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(112), static_cast<u8>(112), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(115), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(91), static_cast<u8>(40), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(93), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(95), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(58), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(100), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(66), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(56), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(56), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(74), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(116), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(67), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(73), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(110), static_cast<u8>(107), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(110), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(78), static_cast<u8>(101), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(79), static_cast<u8>(114), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(40), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(80), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(77), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(58), static_cast<u8>(58), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(114), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(104), static_cast<u8>(105), static_cast<u8>(115), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(86), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(100), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(118), static_cast<u8>(111), static_cast<u8>(105), static_cast<u8>(100), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(66), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(98), static_cast<u8>(111), static_cast<u8>(111), static_cast<u8>(108), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(56), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(56), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(56), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(105), static_cast<u8>(56), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(105), static_cast<u8>(49), static_cast<u8>(54), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(105), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(73), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(105), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(102), static_cast<u8>(51), static_cast<u8>(50), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(70), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(102), static_cast<u8>(54), static_cast<u8>(52), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(115), static_cast<u8>(105), static_cast<u8>(122), static_cast<u8>(101), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(74), static_cast<u8>(97), static_cast<u8>(107), static_cast<u8>(116), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(103), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(67), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(99), static_cast<u8>(104), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(67), static_cast<u8>(73), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(99), static_cast<u8>(95), static_cast<u8>(105), static_cast<u8>(110), static_cast<u8>(116), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(85), static_cast<u8>(110), static_cast<u8>(107), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(110), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(117), static_cast<u8>(110), static_cast<u8>(107), static_cast<u8>(110), static_cast<u8>(111), static_cast<u8>(119), static_cast<u8>(110), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(78), static_cast<u8>(101), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(34), static_cast<u8>(110), static_cast<u8>(101), static_cast<u8>(118), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(34), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(83), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(117), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(79), static_cast<u8>(114), static_cast<u8>(69), static_cast<u8>(110), static_cast<u8>(117), static_cast<u8>(109), static_cast<u8>(40), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(115), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(117), static_cast<u8>(99), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(99), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(100), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(84), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(86), static_cast<u8>(97), static_cast<u8>(114), static_cast<u8>(105), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(80), static_cast<u8>(116), static_cast<u8>(114), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(114), static_cast<u8>(97), static_cast<u8>(119), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(38), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(77), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(97), static_cast<u8>(98), static_cast<u8>(108), static_cast<u8>(101), static_cast<u8>(82), static_cast<u8>(101), static_cast<u8>(102), static_cast<u8>(101), static_cast<u8>(114), static_cast<u8>(101), static_cast<u8>(110), static_cast<u8>(99), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(41), static_cast<u8>(32), static_cast<u8>(61), static_cast<u8>(62), static_cast<u8>(32), static_cast<u8>(102), static_cast<u8>(111), static_cast<u8>(114), static_cast<u8>(109), static_cast<u8>(97), static_cast<u8>(116), static_cast<u8>(40), static_cast<u8>(34), static_cast<u8>(38), static_cast<u8>(109), static_cast<u8>(117), static_cast<u8>(116), static_cast<u8>(32), static_cast<u8>(123), static_cast<u8>(125), static_cast<u8>(34), static_cast<u8>(44), static_cast<u8>(32), static_cast<u8>(116), static_cast<u8>(121), static_cast<u8>(112), static_cast<u8>(101), static_cast<u8>(46), static_cast<u8>(110), static_cast<u8>(97), static_cast<u8>(109), static_cast<u8>(101), static_cast<u8>(40), static_cast<u8>(41), static_cast<u8>(41), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(32), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(125), static_cast<u8>(10), static_cast<u8>(10)}))));
-JaktInternal::Optional<utility::FileId> const old_file_id = ((((*this).compiler))->current_file);
-JaktInternal::DynamicArray<u8> const old_file_contents = ((((*this).compiler))->current_file_contents);
-ScopeGuard __jakt_var_525([&] {
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>>>>{
+auto&& __jakt_match_variant = *condition;
+switch(__jakt_match_variant.index()) {
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs = __jakt_match_value.lhs;
+parser::BinaryOperator const& op = __jakt_match_value.op;
+NonnullRefPtr<typename parser::ParsedExpression> const& rhs = __jakt_match_value.rhs;
 {
-(((((*this).compiler))->current_file) = old_file_id);
-(((((*this).compiler))->current_file_contents) = old_file_contents);
-}
+if (((op).index() == 18 /* LogicalAnd */)){
+JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>> const rhs_condition_rhs_then_block_rhs_else_statement_ = TRY((((*this).expand_context_for_bindings(rhs,acc,then_block,else_statement,span))));
+NonnullRefPtr<typename parser::ParsedExpression> const rhs_condition = ((rhs_condition_rhs_then_block_rhs_else_statement_).template get<0>());
+JaktInternal::Optional<parser::ParsedBlock> const rhs_then_block = ((rhs_condition_rhs_then_block_rhs_else_statement_).template get<1>());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const rhs_else_statement = ((rhs_condition_rhs_then_block_rhs_else_statement_).template get<2>());
 
-});
-utility::FileId const file_id = TRY((((((*this).compiler))->get_file_id_or_register(file_name))));
-(((((*this).compiler))->current_file) = file_id);
-(((((*this).compiler))->current_file_contents) = file_contents);
-types::ModuleId const prelude_module_id = TRY((((*this).create_module(module_name,false,JaktInternal::OptionalNone()))));
-(((*this).current_module_id) = prelude_module_id);
-TRY((((((*this).program))->set_loaded_module(module_name,types::LoadedModule(prelude_module_id,file_id)))));
-types::ScopeId const prelude_scope_id = TRY((((*this).create_scope(JaktInternal::OptionalNone(),false,Jakt::DeprecatedString("prelude"sv),false))));
-JaktInternal::DynamicArray<lexer::Token> const tokens = TRY((lexer::Lexer::lex(((*this).compiler))));
-if (((((*this).compiler))->dump_lexer)){
+NonnullRefPtr<typename parser::ParsedExpression> accumulated_condition = rhs_condition;
+return (TRY((((*this).expand_context_for_bindings(lhs,accumulated_condition,rhs_then_block,rhs_else_statement,span)))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+parser::UnaryOperator const& op = __jakt_match_value.op;
 {
-JaktInternal::ArrayIterator<lexer::Token> _magic = ((tokens).iterator());
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>>>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::UnaryOperator::IsEnumVariant>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& bindings = __jakt_match_value.bindings;
+{
+NonnullRefPtr<typename parser::ParsedExpression> const unary_op_single_condition = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::UnaryOp>(expr, parser::UnaryOperator { typename parser::UnaryOperator::Is(inner) } ,span)));
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>> outer_if_stmts = (TRY((DynamicArray<NonnullRefPtr<typename parser::ParsedStatement>>::create_with({}))));
+{
+JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = ((bindings).iterator());
 for (;;){
-JaktInternal::Optional<lexer::Token> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-lexer::Token token = (_magic_value.value());
+parser::EnumVariantPatternArgument binding = (_magic_value.value());
 {
-outln(Jakt::DeprecatedString("token: {}"sv),token);
+parser::ParsedVarDecl const var = parser::ParsedVarDecl(((binding).binding),TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Empty>())),false,JaktInternal::OptionalNone(),((binding).span));
+NonnullRefPtr<typename parser::ParsedExpression> const enum_variant_arg = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::EnumVariantArg>(expr,binding,inner,span)));
+TRY((((outer_if_stmts).push(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::VarDecl>(var,enum_variant_arg,span)))))));
 }
 
 }
 }
 
+NonnullRefPtr<typename parser::ParsedExpression> inner_condition = condition;
+if (((then_block).has_value())){
+if (((acc).has_value())){
+(inner_condition = (acc.value()));
+TRY((((outer_if_stmts).push(TRY((parser::ParsedStatement::template __jakt_create<typename parser::ParsedStatement::If>(inner_condition,(then_block.value()),else_statement,span)))))));
 }
-parser::ParsedNamespace const parsed_namespace = TRY((parser::Parser::parse(((*this).compiler),tokens)));
-if (((((*this).compiler))->dump_parser)){
-outln(Jakt::DeprecatedString("{:#}"sv),parsed_namespace);
+else {
+TRY((((outer_if_stmts).push_values((((((then_block.value())).stmts)))))));
 }
-((((*this).compiler))->dbg_println(TRY((__jakt_format(Jakt::DeprecatedString("before typechecking parsed prelude, modules ‘{}’"sv),((((*this).program))->modules))))));
-TRY((((*this).typecheck_module(parsed_namespace,prelude_scope_id))));
+
 }
-return {};
+parser::ParsedBlock const new_then_block = parser::ParsedBlock(outer_if_stmts);
+return (TRY((((*this).expand_context_for_bindings(unary_op_single_condition,JaktInternal::OptionalNone(),new_then_block,else_statement,span)))));
 }
-
-ErrorOr<void> typechecker::Typechecker::typecheck_namespace_fields(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
-{
-JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-size_t i = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
 {
-parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
-types::ScopeId const child_namespace_scope_id = ((children)[i]);
-TRY((((*this).typecheck_namespace_fields(child_namespace,child_namespace_scope_id))));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+NonnullRefPtr<typename parser::ParsedExpression> base_condition = condition;
+if (((acc).has_value())){
+(base_condition = TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::BinaryOp>(condition, parser::BinaryOperator { typename parser::BinaryOperator::LogicalAnd() } ,(acc.value()),span))));
 }
+return ((Tuple{base_condition, then_block, else_statement}));
 }
-
-{
-JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedRecord record = (_magic_value.value());
+
+ErrorOr<JaktInternal::Optional<types::TraitId>> typechecker::Typechecker::find_trait_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
 {
-if ((((((record).record_type)).index() == 0 /* Struct */) || ((((record).record_type)).index() == 1 /* Class */))){
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
-if ((!(((struct_id).has_value())))){
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find previously added struct"sv)))));
-}
-TRY((((*this).typecheck_struct_fields(record,(struct_id.value())))));
+return (TRY((((((*this).program))->find_trait_in_scope(scope_id,name)))));
 }
 }
 
+NonnullRefPtr<types::Module> typechecker::Typechecker::current_module() const {
+{
+return (((((*this).program))->get_module(((*this).current_module_id))));
 }
 }
 
+types::ScopeId typechecker::Typechecker::root_scope_id() const {
+{
+return (types::ScopeId(types::ModuleId(static_cast<size_t>(1ULL)),static_cast<size_t>(0ULL)));
 }
-return {};
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_while(NonnullRefPtr<typename parser::ParsedExpression> const condition,parser::ParsedBlock const block,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_defer(NonnullRefPtr<typename parser::ParsedStatement> const statement,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
 {
-NonnullRefPtr<typename types::CheckedExpression> const checked_condition = TRY((((*this).typecheck_expression_and_dereference_if_needed(condition,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-if ((!(((((checked_condition)->type())).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } )))))){
-TRY((((*this).error(Jakt::DeprecatedString("Condition must be a boolean expression"sv),((condition)->span())))));
+bool const was_inside_defer = ((*this).inside_defer);
+(((*this).inside_defer) = true);
+ScopeGuard __jakt_var_490([&] {
+(((*this).inside_defer) = was_inside_defer);
+});
+NonnullRefPtr<typename types::CheckedStatement> const checked_statement = TRY((((*this).typecheck_statement(statement,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+if (((checked_statement)->index() == 5 /* Block */)){
+types::CheckedBlock const block = ((checked_statement)->get<types::CheckedStatement::Block>()).block;
+if (((((block).yielded_type)).has_value())){
+TRY((((*this).error(Jakt::DeprecatedString("‘yield’ inside ‘defer’ is meaningless"sv),span))));
 }
-types::CheckedBlock const checked_block = TRY((((*this).typecheck_block(block,scope_id,safety_mode,JaktInternal::OptionalNone()))));
-if (((((checked_block).yielded_type)).has_value())){
-TRY((((*this).error(Jakt::DeprecatedString("A ‘while’ block is not allowed to yield values"sv),(((block).find_yield_span()).value())))));
 }
-return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::While>(checked_condition,checked_block,span))));
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Defer>(checked_statement,span))));
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::fill_trait_implementation_list(JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> const parsed_impl_list,JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>& trait_implementations,types::ScopeId const scope_id,JaktInternal::Optional<types::ScopeId> const trait_name_scope_id_override) {
+ErrorOr<bool> typechecker::Typechecker::add_function_to_scope(types::ScopeId const parent_scope_id,DeprecatedString const name,JaktInternal::DynamicArray<types::FunctionId> const overload_set,utility::Span const span) {
 {
-types::ScopeId const trait_name_scope_id = trait_name_scope_id_override.value_or_lazy_evaluated([&] { return scope_id; });
+NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(parent_scope_id))));
+if (((((scope)->functions)).contains(name))){
+JaktInternal::DynamicArray<types::FunctionId> const existing_function_binding = ((((scope)->functions))[name]);
 {
-JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((parsed_impl_list).iterator());
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
+types::FunctionId function_id = (_magic_value.value());
 {
-JaktInternal::Optional<types::TypeId> const maybe_type_id = TRY((((*this).find_type_in_scope(trait_name_scope_id,((trait_name).name)))));
-if (((maybe_type_id).has_value())){
-if (((((*this).get_type((maybe_type_id.value()))))->index() == 26 /* Trait */)){
-types::TraitId const trait_id = ((((*this).get_type((maybe_type_id.value()))))->get<types::Type::Trait>()).value;
-JaktInternal::DynamicArray<types::TypeId> generic_arguments = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+NonnullRefPtr<types::CheckedFunction> const function_to_add = ((*this).get_function(function_id));
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((trait_name).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<types::FunctionId> _magic = ((existing_function_binding).iterator());
 for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedType> argument = (_magic_value.value());
+types::FunctionId existing_function_id = (_magic_value.value());
 {
-types::TypeId const argument_type_id = TRY((((*this).typecheck_typename(argument,scope_id,JaktInternal::OptionalNone()))));
-TRY((((generic_arguments).push(argument_type_id))));
-}
-
+NonnullRefPtr<types::CheckedFunction> const existing_function = ((*this).get_function(existing_function_id));
+if (TRY((((function_to_add)->signature_matches(existing_function))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Redefinition of function ‘{}’."sv),((function_to_add)->name)))),(((((function_to_add)->parsed_function).value())).name_span),Jakt::DeprecatedString("Previous definition is here"sv),(((((existing_function)->parsed_function).value())).name_span)))));
 }
 }
 
-TRY((((((trait_implementations))).set(((trait_name).name),(Tuple{trait_id, generic_arguments})))));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Expected ‘{}’ to be a trait"sv),((trait_name).name)))),((trait_name).name_span)))));
-continue;
 }
 
-}
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot find trait ‘{}’"sv),((trait_name).name)))),((trait_name).name_span)))));
-continue;
+TRY((((((((scope)->functions))[name])).push(function_id))));
 }
 
+}
 }
 
 }
+else {
+TRY((((((scope)->functions)).set(name,overload_set))));
 }
 
+TRY((((*this).set_owner_scope_if_needed(parent_scope_id,overload_set))));
+return (true);
 }
-return {};
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_struct_predecl(parser::ParsedRecord const parsed_record,types::StructId const struct_id,types::ScopeId const scope_id) {
-{
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(true))));
-ScopeGuard __jakt_var_526([&] {
+ErrorOr<void> typechecker::Typechecker::check_method_access(types::ScopeId const accessor,types::ScopeId const accessee,NonnullRefPtr<types::CheckedFunction> const method,utility::Span const span) {
 {
-((((*this).generic_inferences)).restore(old_generic_inferences));
-}
-
-});
-types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
-(((*this).current_struct_type_id) = struct_type_id);
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = struct_type_id);
-ScopeGuard __jakt_var_527([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
-types::ScopeId const struct_scope_id = ((((((((*this).current_module()))->structures))[((struct_id).id)])).scope_id);
-TRY((((*this).add_struct_to_scope(scope_id,((parsed_record).name),struct_id,((parsed_record).name_span)))));
-JaktInternal::Optional<types::StructId> super_struct_id = JaktInternal::OptionalNone();
 JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((parsed_record).record_type);
+auto&& __jakt_match_variant = ((method)->visibility);
 switch(__jakt_match_variant.index()) {
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Class>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const& super_parsed_type = __jakt_match_value.super_type;
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<void>>{
-auto __jakt_enum_value = (((super_parsed_type).has_value()));
-if (__jakt_enum_value == true) {
 {
-types::TypeId const super_type_id = TRY((((*this).typecheck_typename((super_parsed_type.value()),scope_id,JaktInternal::OptionalNone()))));
-NonnullRefPtr<typename types::Type> const super_type = ((*this).get_type(super_type_id));
-if (((super_type)->index() == 23 /* Struct */)){
-types::StructId const struct_id = ((super_type)->get<types::Type::Struct>()).value;
-(super_struct_id = struct_id);
+if ((!(TRY((((*this).scope_can_access(accessor,accessee))))))){
+if ((!(((((method)->type)).index() == 0 /* Normal */)))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Can't access constructor ‘{}’, because it is marked private"sv),((method)->name)))),span,Jakt::DeprecatedString("Private constructors are created if any fields are private"sv),span))));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Class can only inherit from another class"sv),(((super_parsed_type.value()))->span())))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't access method ‘{}’, because it is marked private"sv),((method)->name)))),span))));
 }
 
 }
-return JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-}
-return JaktInternal::ExplicitValue<void>();
 }
 return JaktInternal::ExplicitValue<void>();
-}()))
-), JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::Struct>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const& super_parsed_type = __jakt_match_value.super_type;
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<void>>{
-auto __jakt_enum_value = (((super_parsed_type).has_value()));
-if (__jakt_enum_value == true) {
-{
-types::TypeId const super_type_id = TRY((((*this).typecheck_typename((super_parsed_type.value()),scope_id,JaktInternal::OptionalNone()))));
-NonnullRefPtr<typename types::Type> const super_type = ((*this).get_type(super_type_id));
-if (((super_type)->index() == 23 /* Struct */)){
-types::StructId const struct_id = ((super_type)->get<types::Type::Struct>()).value;
-(super_struct_id = struct_id);
-}
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Struct can only inherit from another struct"sv),(((super_parsed_type.value()))->span())))));
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedVisibility::Restricted>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> const& scopes = __jakt_match_value.scopes;
 {
+TRY((((*this).check_restricted_access(accessor,Jakt::DeprecatedString("function"sv),accessee,((method)->name),scopes,span))));
 }
 return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-), JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
 {
-utility::panic(Jakt::DeprecatedString("Expected Struct or Class in typecheck_struct_predecl"sv));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-(((((module)->structures))[((struct_id).id)]) = types::CheckedStruct(((parsed_record).name),((parsed_record).name_span),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),(TRY((DynamicArray<types::CheckedField>::create_with({})))),struct_scope_id,((parsed_record).definition_linkage),(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))),((parsed_record).record_type),struct_type_id,super_struct_id,((parsed_record).external_name)));
-JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters = ((((((module)->structures))[((struct_id).id)])).generic_parameters);
-TRY((((generic_parameters).ensure_capacity(((((parsed_record).generic_parameters)).size())))));
-{
-JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((parsed_record).generic_parameters)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedGenericParameter gen_parameter = (_magic_value.value());
+return {};
+}
+
+ErrorOr<types::TypeId> typechecker::Typechecker::final_type_resolution_form(types::TypeId const type_id,types::ScopeId const scope_id) const {
 {
-types::TypeId const parameter_type_id = types::TypeId(((*this).current_module_id),((((((*this).current_module()))->types)).size()));
-types::CheckedGenericParameter parameter = TRY((types::CheckedGenericParameter::make(parameter_type_id,((gen_parameter).span))));
-JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((gen_parameter).name),trait_implementations)))))));
-if (((((gen_parameter).requires_list)).has_value())){
-TRY((((*this).fill_trait_requirements((((gen_parameter).requires_list).value()),((((parameter).constraints))),((trait_implementations)),scope_id))));
+types::TypeId const mapped_type_id = TRY((((*this).resolve_type_var(type_id,scope_id))));
+if ((((((*this).get_type(mapped_type_id)))->index() == 30 /* Self */) && ((((*this).self_type_id)).has_value()))){
+return ((((*this).self_type_id).value()));
+}
+return (mapped_type_id);
 }
-TRY((((generic_parameters).push(parameter))));
-TRY((((*this).add_type_to_scope(struct_scope_id,((gen_parameter).name),parameter_type_id,((gen_parameter).span)))));
 }
 
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> typechecker::Typechecker::find_scoped_functions_with_name_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
+{
+return (TRY((((((*this).program))->find_scoped_functions_with_name_in_scope(parent_scope_id,function_name)))));
 }
 }
 
-bool const is_extern = ((((parsed_record).definition_linkage)).index() == 1 /* External */);
+ErrorOr<NonnullRefPtr<interpreter::Interpreter>> typechecker::Typechecker::interpreter() {
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((parsed_record).methods)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::ParsedMethod method = (_magic_value.value());
+return (TRY((interpreter::Interpreter::create(((*this).compiler),((*this).program),TRY((types::TypecheckFunctions::__jakt_create([this](parser::ParsedBlock parsed_block, types::ScopeId parent_scope_id, types::SafetyMode safety_mode, JaktInternal::Optional<types::TypeId> yield_type_hint) -> ErrorOr<types::CheckedBlock> {
 {
-types::FunctionId const function_id = TRY((((*this).typecheck_function_predecl(((method).parsed_function),struct_scope_id,struct_type_id,JaktInternal::OptionalNone()))));
-NonnullRefPtr<types::CheckedFunction> checked_function = ((*this).get_function(function_id));
-(((checked_function)->is_override) = ((method).is_override));
-(((checked_function)->is_virtual) = ((method).is_virtual));
-(((checked_function)->visibility) = TRY((((*this).typecheck_visibility(((method).visibility),struct_scope_id)))));
-if ((((checked_function)->is_virtual) && ((checked_function)->is_static()))){
-TRY((((*this).error(Jakt::DeprecatedString("Functions cannot be both virtual and static"sv),((checked_function)->name_span)))));
+return (TRY((((*this).typecheck_block(parsed_block,parent_scope_id,safety_mode,yield_type_hint)))));
 }
-if ((((checked_function)->is_override) && ((checked_function)->is_static()))){
-TRY((((*this).error(Jakt::DeprecatedString("Functions cannot be both override and static"sv),((checked_function)->name_span)))));
+}
+))),(TRY((DynamicArray<utility::Span>::create_with({}))))))));
 }
 }
 
+ErrorOr<void> typechecker::Typechecker::dump_try_hint(utility::Span const span) const {
+{
+outln(Jakt::DeprecatedString("{{\"type\":\"try\",\"file_id\":{},\"position\":{}}}"sv),((((span).file_id)).id),((span).start));
 }
+return {};
 }
 
-if (((((parsed_record).implements_list)).has_value())){
-TRY((((*this).fill_trait_implementation_list((((parsed_record).implements_list).value()),((((((((module)->structures))[((struct_id).id)])).trait_implementations))),struct_scope_id,JaktInternal::OptionalNone()))));
+ErrorOr<void> typechecker::Typechecker::typecheck_module(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
 {
-JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = (((((parsed_record).implements_list).value())).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).typecheck_namespace_imports(parsed_namespace,scope_id))));
+TRY((((*this).typecheck_namespace_predecl(parsed_namespace,scope_id))));
+TRY((((*this).typecheck_namespace_aliases(parsed_namespace,scope_id,typechecker::ImportRestrictions(false,true,true,true,true,true)))));
+TRY((((*this).typecheck_namespace_fields(parsed_namespace,scope_id))));
+TRY((((*this).typecheck_namespace_constructors(parsed_namespace,scope_id))));
+TRY((((*this).typecheck_namespace_function_predecl(parsed_namespace,scope_id))));
+TRY((((*this).typecheck_namespace_aliases(parsed_namespace,scope_id,typechecker::ImportRestrictions(true,false,false,false,false,false)))));
+TRY((((*this).typecheck_namespace_default_fields(parsed_namespace,scope_id))));
+TRY((((*this).typecheck_namespace_declarations(parsed_namespace,scope_id))));
 }
-parser::ParsedNameWithGenericParameters implements_entry = (_magic_value.value());
-{
-JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((implements_entry).name)))));
-if (((trait_id).has_value())){
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((((((((((*this).program))->modules))[(((((trait_id.value())).module)).id)]))->traits))[(((trait_id.value())).id)]);
-{
-JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return {};
 }
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
-DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
-types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
 
-if (((TRY((((*this).find_functions_with_name_in_scope(struct_scope_id,name))))).has_value())){
-continue;
+ErrorOr<void> typechecker::Typechecker::error_with_hint(DeprecatedString const message,utility::Span const span,DeprecatedString const hint,utility::Span const hint_span) {
+{
+if ((!(((*this).ignore_errors)))){
+TRY((((((((*this).compiler))->errors)).push( error::JaktError { typename error::JaktError::MessageWithHint(message,span,hint,hint_span) } ))));
 }
-NonnullRefPtr<types::CheckedFunction> const function = ((((((((((*this).program))->modules))[((((function_id).module)).id)]))->functions))[((function_id).id)]);
-if (((((((function)->block)).statements)).is_empty())){
-continue;
 }
-TRY((((*this).add_function_to_scope(struct_scope_id,name,(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((implements_entry).name_span)))));
+return {};
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_var_decl(parser::ParsedVarDecl const var,NonnullRefPtr<typename parser::ParsedExpression> const init,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span) {
+{
+types::TypeId lhs_type_id = TRY((((*this).typecheck_typename(((var).parsed_type),scope_id,((var).name)))));
+NonnullRefPtr<typename types::CheckedExpression> checked_expr = TRY((((*this).typecheck_expression(init,scope_id,safety_mode,lhs_type_id))));
+types::TypeId const rhs_type_id = ((checked_expr)->type());
+if (((rhs_type_id).equals(types::void_type_id()))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot assign `void` to a variable"sv),((checked_expr)->span())))));
 }
+if ((((lhs_type_id).equals(types::unknown_type_id())) && (!(((rhs_type_id).equals(types::unknown_type_id())))))){
+(lhs_type_id = rhs_type_id);
 }
-
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+if (TRY((((*this).type_contains_reference(lhs_type_id))))){
+JaktInternal::Optional<types::ScopeId> const init_scope_id = TRY((((*this).required_scope_id_in_hierarchy_for(checked_expr,scope_id))));
+if (TRY((((*this).scope_lifetime_subsumes(scope_id,init_scope_id))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot assign a reference to a variable that outlives the reference"sv),((checked_expr)->span())))));
 }
-else {
-continue;
 }
-
+NonnullRefPtr<typename types::Type> const lhs_type = ((*this).get_type(lhs_type_id));
+if (((checked_expr)->index() == 25 /* OptionalNone */)){
+utility::Span const span = ((checked_expr)->get<types::CheckedExpression::OptionalNone>()).span;
+types::TypeId const type_id = ((checked_expr)->get<types::CheckedExpression::OptionalNone>()).type_id;
+if (((lhs_type)->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((lhs_type)->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((lhs_type)->get<types::Type::GenericInstance>()).args;
+if ((!((((id).equals(optional_struct_id)) || ((id).equals(weak_ptr_struct_id)))))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot assign None to a non-optional type"sv),span))));
 }
-
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Cannot assign None to a non-optional type"sv),span))));
 }
 
 }
-(((((((module)->structures))[((struct_id).id)])).generic_parameters) = generic_parameters);
-(((*this).current_struct_type_id) = JaktInternal::OptionalNone());
+if (((lhs_type)->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((lhs_type)->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((lhs_type)->get<types::Type::GenericInstance>()).args;
+if (((id).equals(weak_ptr_struct_id))){
+if ((!(((var).is_mutable)))){
+TRY((((*this).error(Jakt::DeprecatedString("Weak reference must be mutable"sv),((var).span)))));
 }
-return {};
+if (((!(((lhs_type_id).equals(rhs_type_id)))) && ((!(((((args)[static_cast<i64>(0LL)])).equals(rhs_type_id)))) && (!(((rhs_type_id).equals(types::unknown_type_id()))))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
 }
-
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::TypeId,types::ScopeId>>> typechecker::Typechecker::find_type_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
-{
-return (TRY((((((*this).program))->template for_each_scope_accessible_unqualified_from_scope<JaktInternal::Tuple<types::TypeId,types::ScopeId>>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>>> {
-{
-JaktInternal::Optional<types::TypeId> const maybe_type = ((((TRY((((*this).get_scope(scope_id)))))->types)).get(name));
-if (((maybe_type).has_value())){
-return ( typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>> { typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>>::Break((Tuple{(maybe_type.value()), scope_id})) } );
 }
-return ( typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>> { typename utility::IterationDecision<JaktInternal::Tuple<types::TypeId,types::ScopeId>>::Continue() } );
+else if (((id).equals(optional_struct_id))){
+if (((!(((lhs_type_id).equals(rhs_type_id)))) && ((!(((((args)[static_cast<i64>(0LL)])).equals(rhs_type_id)))) && (!(((rhs_type_id).equals(types::unknown_type_id()))))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
 }
 }
-)))))));
+else {
+if (((!(((lhs_type_id).equals(rhs_type_id)))) && (!(((rhs_type_id).equals(types::unknown_type_id())))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
 }
 }
 
-ErrorOr<NonnullRefPtr<interpreter::Interpreter>> typechecker::Typechecker::interpreter() {
-{
-return (TRY((interpreter::Interpreter::create(((*this).compiler),((*this).program),TRY((types::TypecheckFunctions::__jakt_create([this](parser::ParsedBlock parsed_block, types::ScopeId parent_scope_id, types::SafetyMode safety_mode, JaktInternal::Optional<types::TypeId> yield_type_hint) -> ErrorOr<types::CheckedBlock> {
-{
-return (TRY((((*this).typecheck_block(parsed_block,parent_scope_id,safety_mode,yield_type_hint)))));
-}
-}
-))),(TRY((DynamicArray<utility::Span>::create_with({}))))))));
-}
 }
-
-ErrorOr<void> typechecker::Typechecker::check_member_access(types::ScopeId const accessor,types::ScopeId const accessee,NonnullRefPtr<types::CheckedVariable> const member,utility::Span const span) {
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((member)->visibility);
+else if (((lhs_type)->is_builtin())){
+JaktInternal::Optional<types::NumberConstant> const number_constant = ((checked_expr)->to_number_constant(((*this).program)));
+bool is_rhs_zero = false;
+if (((number_constant).has_value())){
+(is_rhs_zero = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<NonnullRefPtr<typename types::CheckedStatement>>>{
+auto&& __jakt_match_variant = (number_constant.value());
 switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Signed>();
+i64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((value == static_cast<i64>(0LL)));
+};/*case end*/
 case 1: {
-{
-if ((!(TRY((((*this).scope_can_access(accessor,accessee))))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't access field ‘{}’, because it is marked private"sv),((member)->name)))),span))));
-}
-}
-return JaktInternal::ExplicitValue<void>();
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Unsigned>();
+u64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((value == static_cast<u64>(0ULL)));
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedVisibility::Restricted>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> const& scopes = __jakt_match_value.scopes;
-{
-TRY((((*this).check_restricted_access(accessor,Jakt::DeprecatedString("field"sv),accessee,((member)->name),scopes,span))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Floating>();
+f64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((value == static_cast<f64>(0)));
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
-));
-}
-return {};
-}
-
-ErrorOr<bool> typechecker::Typechecker::add_struct_to_scope(types::ScopeId const scope_id,DeprecatedString const name,types::StructId const struct_id,utility::Span const span) {
-{
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::StructId> const maybe_scope_id = ((((scope)->structs)).get(name));
-if (((maybe_scope_id).has_value())){
-types::StructId const existing_struct_id = (maybe_scope_id.value());
-utility::Span const definition_span = ((((*this).get_struct(existing_struct_id))).name_span);
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("redefinition of struct/class {}"sv),name))),span,TRY((__jakt_format(Jakt::DeprecatedString("struct/class {} was first defined here"sv),name))),definition_span))));
-return (false);
-}
-TRY((((((scope)->structs)).set(name,struct_id))));
-return (true);
+)));
 }
+if (((!((((*this).is_numeric(lhs_type_id)) && is_rhs_zero))) && (((*this).is_integer(lhs_type_id)) ^ ((*this).is_integer(rhs_type_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::Garbage>(span))));
 }
-
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::infer_unsigned_int(u64 const val,utility::Span const span,JaktInternal::Optional<types::TypeId> const type_hint) {
-{
-NonnullRefPtr<typename types::CheckedExpression> expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } ))));
-if (((type_hint).has_value())){
-types::TypeId const hint = (type_hint.value());
-if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((((type_)->max()) < val)){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
 else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I8((infallible_integer_cast<i8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))));
+if (((!(((lhs_type_id).equals(rhs_type_id)))) && (!(((rhs_type_id).equals(types::unknown_type_id())))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Type mismatch: expected ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(lhs_type_id,false)))),TRY((((*this).type_name(rhs_type_id,false))))))),((checked_expr)->span())))));
+}
 }
 
+NonnullRefPtr<types::CheckedVariable> const checked_var = TRY((types::CheckedVariable::__jakt_create(((var).name),lhs_type_id,((var).is_mutable),((var).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
+if ((((*this).dump_type_hints) && ((((var).inlay_span)).has_value()))){
+TRY((((*this).dump_type_hint(lhs_type_id,(((var).inlay_span).value())))));
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((((type_)->max()) < val)){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::VarId const var_id = TRY((((module)->add_variable(checked_var))));
+TRY((((*this).add_var_to_scope(scope_id,((var).name),var_id,((checked_var)->definition_span)))));
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::VarDecl>(var_id,checked_expr,span))));
 }
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I16((infallible_integer_cast<i16>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))));
 }
 
+bool typechecker::Typechecker::is_subclass_of(types::TypeId const ancestor_type_id,types::TypeId const child_type_id) const {
+{
+NonnullRefPtr<typename types::Type> const ancestor_type = ((*this).get_type(ancestor_type_id));
+NonnullRefPtr<typename types::Type> const child_type = ((*this).get_type(child_type_id));
+if (((ancestor_type)->index() == 23 /* Struct */)){
+types::StructId const ancestor_struct_id = ((ancestor_type)->get<types::Type::Struct>()).value;
+if (((child_type)->index() == 23 /* Struct */)){
+types::StructId const child_struct_id = ((child_type)->get<types::Type::Struct>()).value;
+types::CheckedStruct ancestor_struct = ((*this).get_struct(ancestor_struct_id));
+types::StructId current_struct_id = child_struct_id;
+for (;;){
+types::CheckedStruct const current_struct = ((*this).get_struct(current_struct_id));
+if (((((current_struct).super_struct_id)).has_value())){
+if (((ancestor_struct_id).equals((((current_struct).super_struct_id).value())))){
+return (true);
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((((type_)->max()) < val)){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+(current_struct_id = (((current_struct).super_struct_id).value()));
 }
 else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I32((infallible_integer_cast<i32>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))));
+return (false);
 }
 
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((((type_)->max()) < val)){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+return (false);
 }
 else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8((infallible_integer_cast<u8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))));
+return (false);
 }
 
-}
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((((type_)->max()) < val)){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
 else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U16((infallible_integer_cast<u16>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))));
+return (false);
 }
 
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((((type_)->max()) < val)){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
-}
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U32((infallible_integer_cast<u32>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))));
 }
 
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typechecker::Typechecker::typecheck_inline_cpp(parser::ParsedBlock const block,utility::Span const span,types::SafetyMode const safety_mode) {
+{
+if (((safety_mode).index() == 0 /* Safe */)){
+TRY((((*this).error(Jakt::DeprecatedString("Use of inline cpp block outside of unsafe block"sv),span))));
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))){
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U64((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))));
-}
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))){
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))));
+JaktInternal::DynamicArray<DeprecatedString> strings = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedStatement>> _magic = ((((block).stmts)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } )))){
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } )))));
+NonnullRefPtr<typename parser::ParsedStatement> statement = (_magic_value.value());
+{
+if (((statement)->index() == 0 /* Expression */)){
+NonnullRefPtr<typename parser::ParsedExpression> const expr = ((statement)->get<parser::ParsedStatement::Expression>()).expr;
+if (((expr)->index() == 2 /* QuotedString */)){
+DeprecatedString const val = ((expr)->get<parser::ParsedExpression::QuotedString>()).val;
+utility::Span const span = ((expr)->get<parser::ParsedExpression::QuotedString>()).span;
+TRY((((strings).push(val))));
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((val > static_cast<u64>(255ULL))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Expected block of strings"sv),span))));
+}
+
 }
 else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8((infallible_integer_cast<u8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } )))));
+TRY((((*this).error(Jakt::DeprecatedString("Expected block of strings"sv),span))));
 }
 
 }
+
 }
-return (expr);
+}
+
+return (TRY((types::CheckedStatement::template __jakt_create<typename types::CheckedStatement::InlineCpp>(strings,span))));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_unary_negate(NonnullRefPtr<typename types::CheckedExpression> const expr,utility::Span const span,types::TypeId const type_id) {
+ErrorOr<void> typechecker::Typechecker::typecheck_namespace_predecl(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
 {
-if (((!(((((*this).program))->is_integer(type_id)))) || ((((*this).program))->is_signed(type_id)))){
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } ,span,type_id))));
+size_t const module_struct_len = ((((((*this).current_module()))->structures)).size());
+size_t const module_enum_len = ((((((*this).current_module()))->enums)).size());
+size_t struct_index = static_cast<size_t>(0ULL);
+size_t enum_index = static_cast<size_t>(0ULL);
+{
+JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-types::TypeId const flipped_sign_type = TRY((((((*this).get_type(type_id)))->flip_signedness())));
-types::CheckedNumericConstant const constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedNumericConstant, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *expr;
+parser::ParsedRecord parsed_record = (_magic_value.value());
+{
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((parsed_record).record_type);
 switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NumericConstant>();types::CheckedNumericConstant const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(val);
-};/*case end*/
-default: {
+case 0: {
 {
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } ,span,type_id))));
+TRY((((*this).typecheck_struct_predecl_initial(parsed_record,((struct_index++)),module_struct_len,scope_id))));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-));
-types::NumberConstant const number = (((constant).number_constant()).value());
-size_t const raw_number = ((number).to_usize());
-size_t const max_signed = (infallible_integer_cast<size_t>((((TRY((types::Type::template __jakt_create<typename types::Type::I64>())))->max()))));
-i64 negated_number = static_cast<i64>(0LL);
-if ((raw_number == (JaktInternal::checked_add<size_t>(max_signed,static_cast<size_t>(1ULL))))){
-(negated_number = ((TRY((types::Type::template __jakt_create<typename types::Type::I64>())))->min()));
-}
-if ((raw_number <= max_signed)){
-(negated_number = (JaktInternal::checked_sub<i64>(static_cast<i64>(0LL),(infallible_integer_cast<i64>((raw_number))))));
-}
-types::NumberConstant const negated_number_constant =  types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((negated_number)))) } ;
-if (((raw_number > (JaktInternal::checked_add<size_t>(max_signed,static_cast<size_t>(1ULL)))) || (!(((negated_number_constant).can_fit_number(flipped_sign_type,((*this).program))))))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Negative literal -{} too small for type ‘{}’"sv),raw_number,TRY((((*this).type_name(flipped_sign_type,false))))))),span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(expr, types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } ,span,type_id))));
+case 1: {
+{
+TRY((((*this).typecheck_struct_predecl_initial(parsed_record,((struct_index++)),module_struct_len,scope_id))));
 }
-types::CheckedNumericConstant const new_constant = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedNumericConstant, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *((*this).get_type(flipped_sign_type));
-switch(__jakt_match_variant.index()) {
-case 6: {
-return JaktInternal::ExplicitValue( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I8((infallible_integer_cast<i8>((negated_number)))) } );
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I16((infallible_integer_cast<i16>((negated_number)))) } );
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I32((infallible_integer_cast<i32>((negated_number)))) } );
+case 3: {
+{
+TRY((((*this).typecheck_enum_predecl_initial(parsed_record,((enum_index++)),module_enum_len,scope_id))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I64((infallible_integer_cast<i64>((negated_number)))) } );
+case 2: {
+{
+TRY((((*this).typecheck_enum_predecl_initial(parsed_record,((enum_index++)),module_enum_len,scope_id))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 4: {
 {
-utility::panic(Jakt::DeprecatedString("Unreachable"sv));
 }
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::UnaryOp>(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>(new_constant,span,type_id))), types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } ,span,flipped_sign_type))));
-}
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_dictionary(JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const values,utility::Span const span,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
-{
-if (((*this).dump_try_hints)){
-TRY((((*this).dump_try_hint(span))));
 }
-types::StructId const dictionary_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
-JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> checked_kv_pairs = (TRY((DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>>::create_with({}))));
-types::TypeId key_type_id = types::unknown_type_id();
-JaktInternal::Optional<utility::Span> key_type_span = JaktInternal::OptionalNone();
-types::TypeId value_type_id = types::unknown_type_id();
-JaktInternal::Optional<utility::Span> value_type_span = JaktInternal::OptionalNone();
-JaktInternal::Optional<types::TypeId> key_hint = JaktInternal::OptionalNone();
-JaktInternal::Optional<types::TypeId> value_hint = JaktInternal::OptionalNone();
-JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const type_hint_ids = TRY((((*this).get_type_ids_from_type_hint_if_struct_ids_match(type_hint,dictionary_struct_id))));
-if (((type_hint_ids).has_value())){
-(key_hint = (((type_hint_ids.value()))[static_cast<i64>(0LL)]));
-(value_hint = (((type_hint_ids.value()))[static_cast<i64>(1LL)]));
 }
+
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> _magic = ((values).iterator());
+JaktInternal::ArrayIterator<parser::ParsedNamespace> _magic = ((((parsed_namespace).namespaces)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedNamespace> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>> key__value__ = (_magic_value.value());
+parser::ParsedNamespace namespace_ = (_magic_value.value());
 {
-JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>> const jakt__key__value__ = key__value__;
-NonnullRefPtr<typename parser::ParsedExpression> const key = ((jakt__key__value__).template get<0>());
-NonnullRefPtr<typename parser::ParsedExpression> const value = ((jakt__key__value__).template get<1>());
-
-NonnullRefPtr<typename types::CheckedExpression> const checked_key = TRY((((*this).typecheck_expression(key,scope_id,safety_mode,key_hint))));
-types::TypeId const current_key_type_id = ((checked_key)->type());
-NonnullRefPtr<typename types::CheckedExpression> const checked_value = TRY((((*this).typecheck_expression(value,scope_id,safety_mode,value_hint))));
-types::TypeId const current_value_type_id = ((checked_value)->type());
-types::TypeId const VOID_TYPE_ID = types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } );
-if ((((key_type_id).equals(types::unknown_type_id())) && ((value_type_id).equals(types::unknown_type_id())))){
-if (((current_key_type_id).equals(VOID_TYPE_ID))){
-TRY((((*this).error(Jakt::DeprecatedString("Can't create a dictionary with keys of type void"sv),((key)->span())))));
+DeprecatedString debug_name = Jakt::DeprecatedString("namespace("sv);
+if (((((namespace_).name)).has_value())){
+(debug_name += (((namespace_).name).value()));
 }
-if (((current_value_type_id).equals(VOID_TYPE_ID))){
-TRY((((*this).error(Jakt::DeprecatedString("Can't create a dictionary with values of type void"sv),((value)->span())))));
+else {
+(debug_name += Jakt::DeprecatedString("unnamed-namespace"sv));
 }
-(key_type_id = current_key_type_id);
-(key_type_span = static_cast<JaktInternal::Optional<utility::Span>>(((key)->span())));
-(value_type_id = current_value_type_id);
-(value_type_span = static_cast<JaktInternal::Optional<utility::Span>>(((value)->span())));
+
+(debug_name += Jakt::DeprecatedString(")"sv));
+types::ScopeId const parent_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId,ErrorOr<void>>{
+auto __jakt_enum_value = (((((namespace_).import_path_if_extern)).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(types::ScopeId(types::ModuleId(static_cast<size_t>(1ULL)),static_cast<size_t>(0ULL)));
 }
 else {
-if ((!(((key_type_id).equals(current_key_type_id))))){
-DeprecatedString const key_type_name = TRY((((*this).type_name(key_type_id,false))));
-DeprecatedString const current_key_type_name = TRY((((*this).type_name(current_key_type_id,false))));
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' does not match type '{}' of previous keys in dictionary"sv),current_key_type_name,key_type_name))),((key)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Dictionary was inferred to store keys of type '{}' here"sv),key_type_name))),(key_type_span.value())))));
+return JaktInternal::ExplicitValue(scope_id);
 }
-if ((!(((value_type_id).equals(current_value_type_id))))){
-DeprecatedString const value_type_name = TRY((((*this).type_name(value_type_id,false))));
-DeprecatedString const current_value_type_name = TRY((((*this).type_name(current_value_type_id,false))));
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type '{}' does not match type '{}' of previous values in dictionary"sv),current_value_type_name,value_type_name))),((value)->span()),TRY((__jakt_format(Jakt::DeprecatedString("Dictionary was inferred to store values of type '{}' here"sv),value_type_name))),(value_type_span.value())))));
+}()))
+;
+types::ScopeId const namespace_scope_id = TRY((((*this).create_scope(parent_scope_id,false,debug_name,false))));
+NonnullRefPtr<types::Scope> child_scope = TRY((((*this).get_scope(namespace_scope_id))));
+(((child_scope)->namespace_name) = ((namespace_).name));
+(((child_scope)->import_path_if_extern) = ((namespace_).import_path_if_extern));
+(((child_scope)->before_extern_include) = ((namespace_).generating_import_extern_before_include));
+(((child_scope)->after_extern_include) = ((namespace_).generating_import_extern_after_include));
+if (((((namespace_).import_path_if_extern)).has_value())){
+TRY((((((child_scope)->resolution_mixins)).push(scope_id))));
 }
+NonnullRefPtr<types::Scope> parent_scope = TRY((((*this).get_scope(scope_id))));
+TRY((((((parent_scope)->children)).push(namespace_scope_id))));
+TRY((((*this).typecheck_namespace_predecl(namespace_,namespace_scope_id))));
 }
 
-TRY((((checked_kv_pairs).push((Tuple{checked_key, checked_value})))));
+}
 }
 
+{
+JaktInternal::ArrayIterator<parser::ParsedTrait> _magic = ((((parsed_namespace).traits)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedTrait> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+parser::ParsedTrait parsed_trait = (_magic_value.value());
+{
+TRY((((*this).typecheck_trait_predecl(parsed_trait,scope_id))));
 }
 
-if (((key_type_id).equals(types::unknown_type_id()))){
-if (((key_hint).has_value())){
-(key_type_id = (key_hint.value()));
 }
-else {
-TRY((((*this).error(Jakt::DeprecatedString("Cannot infer key type for Dictionary<K, V>"sv),span))));
 }
 
+{
+JaktInternal::ArrayIterator<parser::ParsedTrait> _magic = ((((parsed_namespace).traits)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedTrait> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-if (((value_type_id).equals(types::unknown_type_id()))){
-if (((value_hint).has_value())){
-(value_type_id = (value_hint.value()));
+parser::ParsedTrait parsed_trait = (_magic_value.value());
+{
+JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((parsed_trait).name)))));
+if (((trait_id).has_value())){
+TRY((((*this).typecheck_trait(parsed_trait,(trait_id.value()),scope_id))));
 }
 else {
-TRY((((*this).error(Jakt::DeprecatedString("Cannot infer value type for Dictionary"sv),span))));
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("can't find trait that has been previous added"sv)))));
 }
 
-}
-types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(dictionary_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({key_type_id, value_type_id})))))))))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::JaktDictionary>(checked_kv_pairs,span,type_id,key_type_id,value_type_id))));
-}
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_alias(parser::ParsedAlias const alias,types::ScopeId const scope_id,typechecker::ImportRestrictions const allow) {
-{
-parser::ParsedName const aliased_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<parser::ParsedName,ErrorOr<void>>{
-auto __jakt_enum_value = (((((alias).alias_name)).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue((((alias).alias_name).value()));
 }
-else {
-return JaktInternal::ExplicitValue(({ Optional<parser::ParsedName> __jakt_var_528; {
-parser::ParsedNameWithGenericParameters const name = (((((alias).target)).last()).value());
-if ((!(((((name).generic_parameters)).is_empty())))){
-TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Cannot alias a generic instance of a type to the type itself"sv)))),((name).name_span),TRY((__jakt_format(Jakt::DeprecatedString("Add an alias name here: 'as <name>'"sv)))),((name).name_span)))));
 }
-__jakt_var_528 = parser::ParsedName(((name).name),((name).name_span)); goto __jakt_label_473;
 
-}
-__jakt_label_473:; __jakt_var_528.release_value(); }));
-}
-}()))
-;
-types::ScopeId resolved_scope_id = scope_id;
-JaktInternal::DynamicArray<types::ResolvedNamespace> alias_path = (TRY((DynamicArray<types::ResolvedNamespace>::create_with({}))));
+(struct_index = static_cast<size_t>(0ULL));
+(enum_index = static_cast<size_t>(0ULL));
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>((JaktInternal::checked_sub<size_t>(((((alias).target)).size()),static_cast<size_t>(1ULL))))});
+JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+parser::ParsedRecord parsed_record = (_magic_value.value());
 {
-JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const namespace_ = TRY((((*this).find_namespace_in_scope(resolved_scope_id,((((((alias).target))[i])).name),false))));
-if ((!(((namespace_).has_value())))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown namespace '{}'"sv),((((((alias).target))[i])).name)))),((((((alias).target))[i])).name_span)))));
-return {};
-}
-(resolved_scope_id = (((namespace_.value())).template get<0>()));
-TRY((((alias_path).push(types::ResolvedNamespace(((((((alias).target))[i])).name),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())))));
+types::StructId const struct_id = types::StructId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(struct_index,module_struct_len)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = ((parsed_record).record_type);
+switch(__jakt_match_variant.index()) {
+case 0: {
+{
+TRY((((*this).typecheck_struct_predecl(parsed_record,struct_id,scope_id))));
+((struct_index++));
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 1: {
+{
+TRY((((*this).typecheck_struct_predecl(parsed_record,struct_id,scope_id))));
+((struct_index++));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 3: {
+{
+types::EnumId const enum_id = types::EnumId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(enum_index,module_enum_len)));
+TRY((((*this).typecheck_enum_predecl(parsed_record,enum_id,scope_id))));
+((enum_index++));
 }
-
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
-types::ScopeId const alias_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId,ErrorOr<void>>{
-auto __jakt_enum_value = (((((scope)->alias_scope)).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue((((scope)->alias_scope).value()));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 2: {
+{
+types::EnumId const enum_id = types::EnumId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(enum_index,module_enum_len)));
+TRY((((*this).typecheck_enum_predecl(parsed_record,enum_id,scope_id))));
+((enum_index++));
 }
-else {
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_529; {
-types::ScopeId const new_scope_id = TRY((((*this).create_scope(scope_id,false,TRY((__jakt_format(Jakt::DeprecatedString("alias-scope({})"sv),((scope)->debug_name)))),false))));
-NonnullRefPtr<types::Scope> new_scope = TRY((((*this).get_scope(new_scope_id))));
-(((new_scope)->alias_path) = alias_path);
-TRY((((((TRY((((*this).get_scope(scope_id)))))->children)).push(new_scope_id))));
-__jakt_var_529 = new_scope_id; goto __jakt_label_474;
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 4: {
+{
 }
-__jakt_label_474:; __jakt_var_529.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
 }
-}()))
-;
-TRY((((*this).find_and_import_name_from_scope((((((((alias).target)).last()).value())).name),(((((((alias).target)).last()).value())).name_span),((aliased_name).name),((aliased_name).span),resolved_scope_id,alias_scope_id,allow))));
+
 }
-return {};
 }
 
-ErrorOr<types::TypeId> typechecker::Typechecker::unify_with_type(types::TypeId const found_type,JaktInternal::Optional<types::TypeId> const expected_type,utility::Span const span) {
 {
-if ((!(((expected_type).has_value())))){
-return (found_type);
-}
-if ((((expected_type.value())).equals(types::unknown_type_id()))){
-return (found_type);
-}
-if (TRY((((*this).check_types_for_compat((expected_type.value()),found_type,((((*this).generic_inferences))),span))))){
-return (found_type);
-}
-return (TRY((((*this).substitute_typevars_in_type(found_type,((*this).generic_inferences))))));
-}
+JaktInternal::ArrayIterator<parser::ParsedExternalTraitImplementation> _magic = ((((parsed_namespace).external_trait_implementations)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedExternalTraitImplementation> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-ErrorOr<void> typechecker::Typechecker::typecheck_trait_predecl(parser::ParsedTrait const parsed_trait,types::ScopeId const scope_id) {
+parser::ParsedExternalTraitImplementation implementation = (_magic_value.value());
 {
-types::ScopeId const trait_scope_id = TRY((((*this).create_scope(scope_id,false,TRY((__jakt_format(Jakt::DeprecatedString("trait({})"sv),((parsed_trait).name)))),false))));
-TRY((((*this).add_type_to_scope(trait_scope_id,Jakt::DeprecatedString("Self"sv),TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Self>())))))),((parsed_trait).name_span)))));
-NonnullRefPtr<types::CheckedTrait> checked_trait = TRY((types::CheckedTrait::__jakt_create(((parsed_trait).name),((parsed_trait).name_span),(TRY((Dictionary<DeprecatedString, types::FunctionId>::create_with_entries({})))),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),trait_scope_id)));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::TraitId const trait_id = types::TraitId(((*this).current_module_id),((((((((((*this).program))->modules))[((((*this).current_module_id)).id)]))->traits)).size()));
-types::TypeId const trait_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Trait>(trait_id)))))));
-TRY((((((((((((*this).program))->modules))[((((*this).current_module_id)).id)]))->traits)).push(checked_trait))));
+types::TypeId const for_type = TRY((((*this).typecheck_typename(((implementation).for_type),scope_id,JaktInternal::OptionalNone()))));
 JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = trait_type_id);
-ScopeGuard __jakt_var_530([&] {
+(((*this).self_type_id) = for_type);
+ScopeGuard __jakt_var_491([&] {
+{
 (((*this).self_type_id) = old_self_type_id);
+}
+
 });
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(scope_id))));
-TRY((((*this).add_type_to_scope(scope_id,((parsed_trait).name),trait_type_id,((parsed_trait).name_span)))));
-TRY((((*this).add_trait_to_scope(scope_id,((parsed_trait).name),trait_id,((parsed_trait).name_span)))));
-JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters = ((((((module)->traits))[((trait_id).id)]))->generic_parameters);
-TRY((((generic_parameters).ensure_capacity(((((parsed_trait).generic_parameters)).size())))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
+auto&& __jakt_match_variant = *((*this).get_type(for_type));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((parsed_trait).generic_parameters)).iterator());
+types::CheckedStruct struct_ = ((*this).get_struct(struct_id));
+{
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedGenericParameter gen_parameter = (_magic_value.value());
+parser::ParsedMethod method = (_magic_value.value());
 {
-types::TypeId const parameter_type_id = types::TypeId(((*this).current_module_id),((((((*this).current_module()))->types)).size()));
-JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-types::CheckedGenericParameter parameter = TRY((types::CheckedGenericParameter::make(parameter_type_id,((gen_parameter).span))));
-TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((gen_parameter).name),trait_implementations)))))));
-if (((((gen_parameter).requires_list)).has_value())){
-TRY((((*this).fill_trait_requirements((((gen_parameter).requires_list).value()),((((parameter).constraints))),((trait_implementations)),scope_id))));
+JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
+if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
+(this_arg_type_id = for_type);
 }
-TRY((((generic_parameters).push(parameter))));
-TRY((((*this).add_type_to_scope(trait_scope_id,((gen_parameter).name),parameter_type_id,((gen_parameter).span)))));
+TRY((((*this).typecheck_function_predecl(((method).parsed_function),((struct_).scope_id),this_arg_type_id,JaktInternal::OptionalNone()))));
 }
 
 }
 }
 
-types::StructId const synthetic_struct_id = types::StructId(((*this).current_module_id),((((((((((*this).program))->modules))[((((*this).current_module_id)).id)]))->structures)).size()));
-TRY((((((module)->structures)).push(types::CheckedStruct(((parsed_trait).name),((parsed_trait).name_span),generic_parameters,(TRY((DynamicArray<types::CheckedField>::create_with({})))),trait_scope_id, parser::DefinitionLinkage { typename parser::DefinitionLinkage::External() } ,(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))), parser::RecordType { typename parser::RecordType::Struct((TRY((DynamicArray<parser::ParsedField>::create_with({})))),JaktInternal::OptionalNone()) } ,trait_type_id,JaktInternal::OptionalNone(),JaktInternal::OptionalNone())))));
-types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(synthetic_struct_id)))))));
+TRY((((*this).fill_trait_implementation_list(((implementation).traits),((((struct_).trait_implementations))),((struct_).scope_id),scope_id))));
 {
-JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((parsed_trait).methods)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((((implementation).traits)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedFunction parsed_function = (_magic_value.value());
+parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
 {
-types::ScopeId const method_scope_id = TRY((((*this).create_scope(trait_scope_id,((parsed_function).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("trait-method({}::{})"sv),((parsed_trait).name),((parsed_function).name)))),true))));
-types::FunctionId const function_id = ((((((*this).program))->get_module(((*this).current_module_id))))->next_function_id());
-JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
-if (((!(((((parsed_function).params)).is_empty()))) && ((((((((((parsed_function).params)).first()).value())).variable)).name) == Jakt::DeprecatedString("this"sv)))){
-(this_arg_type_id = struct_type_id);
-}
-TRY((((*this).typecheck_function_predecl(parsed_function,trait_scope_id,this_arg_type_id,JaktInternal::OptionalNone()))));
-TRY((((((checked_trait)->methods)).set(((parsed_function).name),function_id))));
+JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((trait_name).name)))));
+if (((trait_id).has_value())){
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait((trait_id.value())));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
+DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
+types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
 
+if (((TRY((((*this).find_functions_with_name_in_scope(((struct_).scope_id),name))))).has_value())){
+continue;
+}
+NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
+if (((((((function)->block)).statements)).is_empty())){
+continue;
+}
+NonnullRefPtr<types::CheckedFunction> replaced_function = TRY((((function)->copy())));
+types::GenericInferences const inferences = ((*this).generic_inferences);
+TRY((((replaced_function)->map_types((([inferences](types::TypeId type_id) -> ErrorOr<types::TypeId> {
+{
+return (TRY((((inferences).map(type_id)))));
+}
 }
+))))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::FunctionId const new_function_id = TRY((((module)->add_function(replaced_function))));
+TRY((((*this).add_function_to_scope(((struct_).scope_id),name,(TRY((DynamicArray<types::FunctionId>::create_with({new_function_id})))),((trait_name).name_span)))));
 }
 
 }
-return {};
 }
 
-types::BlockControlFlow typechecker::Typechecker::statement_control_flow(NonnullRefPtr<typename types::CheckedStatement> const statement) const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = *statement;
-switch(__jakt_match_variant.index()) {
-case 8: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(true) } );
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(false) } );
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((((expr)->control_flow())).updated( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(false) } )));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& then_block = __jakt_match_value.then_block;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const& else_statement = __jakt_match_value.else_statement;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = *condition;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();bool const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
-auto __jakt_enum_value = (val);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((then_block).control_flow));
 }
 else {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
-auto __jakt_enum_value = (((else_statement).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((*this).statement_control_flow((else_statement.value()))));
+continue;
 }
-else {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+
 }
-}()))
-);
+
 }
-}()))
-);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(((((then_block).control_flow)).branch_unify_with(((*this).maybe_statement_control_flow(else_statement,((then_block).control_flow))))));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(((block).control_flow));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();NonnullRefPtr<typename types::CheckedExpression> const& condition = __jakt_match_value.condition;
-types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = *condition;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();bool const& val = __jakt_match_value.val;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
-auto __jakt_enum_value = (val);
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = ((block).control_flow);
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-}/*switch end*/
-}()
-)));
 }
-else {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-}
-}()))
-);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();types::CheckedBlock const& block = __jakt_match_value.block;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = ((block).control_flow);
-switch(__jakt_match_variant.index()) {
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
-auto __jakt_enum_value = (might_break);
-if (__jakt_enum_value == false) {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
-}
-else {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-}
-}()))
-);
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
-auto __jakt_enum_value = (((((block).control_flow)).may_break()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-}
-else {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = ((block).control_flow);
-switch(__jakt_match_variant.index()) {
-case 4: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-}/*switch end*/
-}()
-)));
+
 }
-}()))
-);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->control_flow()));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<JaktInternal::Optional<types::FunctionId>> typechecker::Typechecker::find_function_matching_signature_in_scope(types::ScopeId const parent_scope_id,parser::ParsedFunction const prototype) const {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
 {
-DeprecatedString const function_name = ((prototype).name);
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const candidate_ids = TRY((((((*this).program))->find_functions_with_name_in_scope(parent_scope_id,function_name))));
-if (((candidate_ids).has_value())){
+types::CheckedStruct struct_ = ((*this).get_struct(struct_id));
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = (((candidate_ids.value())).iterator());
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId candidate_id = (_magic_value.value());
+parser::ParsedMethod method = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedFunction> const candidate = ((*this).get_function(candidate_id));
-if ((((((candidate)->parsed_function)).has_value()) && (((((candidate)->parsed_function).value())).equals(prototype)))){
-return (candidate_id);
-}
-}
-
+JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
+if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
+(this_arg_type_id = for_type);
 }
+TRY((((*this).typecheck_function_predecl(((method).parsed_function),((struct_).scope_id),this_arg_type_id,JaktInternal::OptionalNone()))));
 }
 
-}
-return (JaktInternal::OptionalNone());
 }
 }
 
-ErrorOr<void> typechecker::Typechecker::map_generic_arguments(types::TypeId const type_id,JaktInternal::DynamicArray<types::TypeId> const args) {
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = *((*this).get_type(type_id));
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+TRY((((*this).fill_trait_implementation_list(((implementation).traits),((((struct_).trait_implementations))),((struct_).scope_id),scope_id))));
 {
-types::CheckedStruct const struct_ = ((*this).get_struct(id));
-TRY((((((*this).generic_inferences)).set_all(((struct_).generic_parameters),args))));
+JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((((implementation).traits)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
 {
-types::CheckedEnum const enum_ = ((*this).get_enum(id));
-TRY((((((*this).generic_inferences)).set_all(((enum_).generic_parameters),args))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((trait_name).name)))));
+if (((trait_id).has_value())){
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait((trait_id.value())));
 {
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait(id));
-TRY((((((*this).generic_inferences)).set_all(((trait_)->generic_parameters),args))));
+JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-default: {
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
 {
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
+DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
+types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
+
+if (((TRY((((*this).find_functions_with_name_in_scope(((struct_).scope_id),name))))).has_value())){
+continue;
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
-}
-return {};
+NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
+if (((((((function)->block)).statements)).is_empty())){
+continue;
 }
-
-ErrorOr<bool> typechecker::Typechecker::validate_argument_label(types::CheckedParameter const param,DeprecatedString const label,utility::Span const span,NonnullRefPtr<typename parser::ParsedExpression> const expr,JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const default_value) {
+NonnullRefPtr<types::CheckedFunction> replaced_function = TRY((((function)->copy())));
+types::GenericInferences const inferences = ((*this).generic_inferences);
+TRY((((replaced_function)->map_types((([inferences](types::TypeId type_id) -> ErrorOr<types::TypeId> {
 {
-DeprecatedString const name = ((*this).get_argument_name((Tuple{label, span, expr})));
-if ((name == ((((param).variable))->name))){
-return (true);
+return (TRY((((inferences).map(type_id)))));
 }
-if ((!(((default_value).has_value())))){
-if (((label).is_empty())){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Missing argument label (expected '{}:')"sv),((((param).variable))->name)))),((expr)->span())))));
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Wrong parameter name in argument label (got '{}', expected '{}')"sv),label,((((param).variable))->name)))),span))));
+))))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::FunctionId const new_function_id = TRY((((module)->add_function(replaced_function))));
+TRY((((*this).add_function_to_scope(((struct_).scope_id),name,(TRY((DynamicArray<types::FunctionId>::create_with({new_function_id})))),((trait_name).name_span)))));
 }
 
-}
-return (false);
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::infer_signed_int(i64 const val,utility::Span const span,JaktInternal::Optional<types::TypeId> const type_hint) {
-{
-NonnullRefPtr<typename types::CheckedExpression> expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } ))));
-if (((type_hint).has_value())){
-types::TypeId const hint = (type_hint.value());
-if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
 else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I8((infallible_integer_cast<i8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))));
+continue;
 }
 
-}
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
-}
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I16((infallible_integer_cast<i16>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))));
 }
 
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
-}
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I32((infallible_integer_cast<i32>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))));
 }
 
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+{
+types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
+{
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8((infallible_integer_cast<u8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))));
+parser::ParsedMethod method = (_magic_value.value());
+{
+JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
+if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
+(this_arg_type_id = for_type);
 }
-
+TRY((((*this).typecheck_function_predecl(((method).parsed_function),((enum_).scope_id),this_arg_type_id,JaktInternal::OptionalNone()))));
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
+
 }
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U16((infallible_integer_cast<u16>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))));
 }
 
+TRY((((*this).fill_trait_implementation_list(((implementation).traits),((((enum_).trait_implementations))),((enum_).scope_id),scope_id))));
+{
+JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((((implementation).traits)).iterator());
+for (;;){
+JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if (((val < ((type_)->min())) || (val > (infallible_integer_cast<i64>((((type_)->max()))))))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
-}
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U32((infallible_integer_cast<u32>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))));
+parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
+{
+JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((trait_name).name)))));
+if (((trait_id).has_value())){
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait((trait_id.value())));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
+DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
+types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
 
+if (((TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),name))))).has_value())){
+continue;
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((val < static_cast<i64>(0LL))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
-}
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U64((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))));
+NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
+if (((((((function)->block)).statements)).is_empty())){
+continue;
 }
-
+NonnullRefPtr<types::CheckedFunction> replaced_function = TRY((((function)->copy())));
+types::GenericInferences const inferences = ((*this).generic_inferences);
+TRY((((replaced_function)->map_types((([inferences](types::TypeId type_id) -> ErrorOr<types::TypeId> {
+{
+return (TRY((((inferences).map(type_id)))));
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((val < static_cast<i64>(0LL))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))));
+))))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::FunctionId const new_function_id = TRY((((module)->add_function(replaced_function))));
+TRY((((*this).add_function_to_scope(((enum_).scope_id),name,(TRY((DynamicArray<types::FunctionId>::create_with({new_function_id})))),((trait_name).name_span)))));
 }
 
 }
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if ((val < static_cast<i64>(0LL))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
-}
-else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize((infallible_integer_cast<u64>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } )))));
 }
 
-}
-else if (((hint).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } )))){
-types::TypeId const builtin_typeid = types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } );
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(builtin_typeid));
-if (((val < static_cast<i64>(0LL)) || (val > static_cast<i64>(255LL)))){
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Integer promotion failed"sv),span,TRY((__jakt_format(Jakt::DeprecatedString("Cannot fit value into range [{}, {}] of type {}."sv),((type_)->min()),((type_)->max()),TRY((((*this).type_name(builtin_typeid,false))))))),span))));
 }
 else {
-(expr = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8((infallible_integer_cast<u8>((val)))) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } )))));
+continue;
 }
 
-}
-}
-return (expr);
-}
 }
 
-NonnullRefPtr<typename types::Type> typechecker::Typechecker::get_type(types::TypeId const id) const {
-{
-return (((((*this).program))->get_type(id)));
 }
 }
 
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_indexed_struct(NonnullRefPtr<typename parser::ParsedExpression> const expr,DeprecatedString const field_name,types::ScopeId const scope_id,bool const is_optional,types::SafetyMode const safety_mode,utility::Span const span) {
-{
-NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
-types::TypeId const checked_expr_type_id = ((checked_expr)->type());
-NonnullRefPtr<typename types::Type> const checked_expr_type = ((*this).get_type(checked_expr_type_id));
-types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *checked_expr_type;
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-{
-types::TypeId type_id = checked_expr_type_id;
-if (is_optional){
-if ((!(((id).equals(optional_struct_id))))){
-TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is only allowed on optional types"sv),span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,types::unknown_type_id()))));
-}
-(type_id = ((args)[static_cast<i64>(0LL)]));
 }
-NonnullRefPtr<typename types::Type> const type = ((*this).get_type(type_id));
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-ScopeGuard __jakt_var_531([&] {
-((((*this).generic_inferences)).restore(checkpoint));
-});
-TRY((((*this).map_generic_arguments(type_id,args))));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
-auto&& __jakt_match_variant = *type;
-switch(__jakt_match_variant.index()) {
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
 {
-types::CheckedStruct const structure = ((*this).get_struct(struct_id));
+types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((implementation).methods)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedField field = (_magic_value.value());
+parser::ParsedMethod method = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
-if ((((member)->name) == field_name)){
-types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
-if (is_optional){
-(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
-}
-TRY((((*this).check_member_access(scope_id,((structure).scope_id),member,span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,resolved_type_id))));
+JaktInternal::Optional<types::TypeId> this_arg_type_id = JaktInternal::OptionalNone();
+if ((((((((((((method).parsed_function)).params)).first())).map([](auto& _value) { return _value.variable; }))).map([](auto& _value) { return _value.name; })).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }) == Jakt::DeprecatedString("this"sv))){
+(this_arg_type_id = for_type);
 }
+TRY((((*this).typecheck_function_predecl(((method).parsed_function),((enum_).scope_id),this_arg_type_id,JaktInternal::OptionalNone()))));
 }
 
 }
 }
 
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field_name))),span))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-{
-types::CheckedStruct const structure = ((*this).get_struct(struct_id));
+TRY((((*this).fill_trait_implementation_list(((implementation).traits),((((enum_).trait_implementations))),((enum_).scope_id),scope_id))));
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((((implementation).traits)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedField field = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
-if ((((member)->name) == field_name)){
-types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
-if (is_optional){
-(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
-}
-TRY((((*this).check_member_access(scope_id,((structure).scope_id),member,span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,resolved_type_id))));
-}
-}
-
-}
-}
-
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field_name))),span))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+parser::ParsedNameWithGenericParameters trait_name = (_magic_value.value());
 {
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,((trait_name).name)))));
+if (((trait_id).has_value())){
+NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait((trait_id.value())));
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
+JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((((trait_)->methods)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedField field = (_magic_value.value());
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> name__function_id__ = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
-if ((((member)->name) == field_name)){
-types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
-if (is_optional){
-(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__name__function_id__ = name__function_id__;
+DeprecatedString const name = ((jakt__name__function_id__).template get<0>());
+types::FunctionId const function_id = ((jakt__name__function_id__).template get<1>());
+
+if (((TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),name))))).has_value())){
+continue;
 }
-TRY((((*this).check_member_access(scope_id,((enum_).scope_id),member,span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedCommonEnumMember>(checked_expr,field_name,span,is_optional,resolved_type_id))));
+NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
+if (((((((function)->block)).statements)).is_empty())){
+continue;
 }
+NonnullRefPtr<types::CheckedFunction> replaced_function = TRY((((function)->copy())));
+types::GenericInferences const inferences = ((*this).generic_inferences);
+TRY((((replaced_function)->map_types((([inferences](types::TypeId type_id) -> ErrorOr<types::TypeId> {
+{
+return (TRY((((inferences).map(type_id)))));
 }
-
 }
+))))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::FunctionId const new_function_id = TRY((((module)->add_function(replaced_function))));
+TRY((((*this).add_function_to_scope(((enum_).scope_id),name,(TRY((DynamicArray<types::FunctionId>::create_with({new_function_id})))),((trait_name).name_span)))));
 }
 
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown common member of enum: {}.{}"sv),((enum_).name),field_name))),span))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-{
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-{
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::CheckedField field = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
-if ((((member)->name) == field_name)){
-types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
-if (is_optional){
-(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+
 }
-TRY((((*this).check_member_access(scope_id,((enum_).scope_id),member,span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedCommonEnumMember>(checked_expr,field_name,span,is_optional,resolved_type_id))));
+else {
+continue;
 }
+
 }
 
 }
 }
 
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown common member of enum: {}.{}"sv),((enum_).name),field_name))),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return (TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Member field access on value of non-struct type ‘{}’"sv),TRY((((*this).type_name(checked_expr_type_id,false))))))),span))))), JaktInternal::ExplicitValue<void>();
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot implement traits for type '{}'"sv),TRY((((*this).type_name(for_type,false))))))),((((implementation).for_type))->span())))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-{
-if (is_optional){
-TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on non-optional types"sv),span))));
+
 }
-types::CheckedStruct const structure = ((*this).get_struct(struct_id));
-JaktInternal::Optional<types::FieldRecord> const field_record = TRY((((*this).lookup_struct_field(struct_id,field_name))));
-if (((field_record).has_value())){
-NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable((((field_record.value())).field_id)));
-types::TypeId const resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
-TRY((((*this).check_member_access(scope_id,((((*this).get_struct((((field_record.value())).struct_id)))).scope_id),member,span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,resolved_type_id))));
 }
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field_name))),span))));
+
 }
-return JaktInternal::ExplicitValue<void>();
+return {};
+}
+
+bool typechecker::Typechecker::is_struct(types::TypeId const type_id) const {
+{
+if (((((*this).get_type(type_id)))->index() == 23 /* Struct */)){
+types::StructId const struct_id = ((((*this).get_type(type_id)))->get<types::Type::Struct>()).value;
+return (((((((*this).get_struct(struct_id))).record_type)).index() == 0 /* Struct */));
+}
+else {
+return (false);
+}
+
+}
+}
+
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_expression(NonnullRefPtr<typename parser::ParsedExpression> const expr,types::ScopeId const scope_id,types::SafetyMode const safety_mode,JaktInternal::Optional<types::TypeId> const type_hint) {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *expr;
+switch(__jakt_match_variant.index()) {
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedStruct>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+DeprecatedString const& field_name = __jakt_match_value.field_name;
+utility::Span const& span = __jakt_match_value.span;
+bool const& is_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_struct(expr,field_name,scope_id,is_optional,safety_mode,span)))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ComptimeIndex>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+NonnullRefPtr<typename parser::ParsedExpression> const& index = __jakt_match_value.index;
+utility::Span const& span = __jakt_match_value.span;
+bool const& is_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_comptime_index(expr,index,scope_id,is_optional,safety_mode,span)))));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Boolean>();bool const& val = __jakt_match_value.val;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_492; {
+TRY((((*this).unify_with_type(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ),type_hint,span))));
+__jakt_var_492 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Boolean>(val,span))); goto __jakt_label_434;
+
+}
+__jakt_label_434:; __jakt_var_492.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NumericConstant>();parser::NumericConstant const& val = __jakt_match_value.val;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_493; {
+JaktInternal::Optional<types::TypeId> type_hint_unwrapped = type_hint;
+if ((((type_hint).has_value()) && ((((*this).get_type((type_hint.value()))))->index() == 19 /* GenericInstance */))){
+types::StructId const id = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).args;
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+if (((id).equals(optional_struct_id))){
+(type_hint_unwrapped = ((args)[static_cast<i64>(0LL)]));
+}
+}
+__jakt_var_493 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = val;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I8>();
+i8 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I8(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } )))));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I16>();
+i16 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I16(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } )))));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I32>();
+i32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I32(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } )))));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::I64>();
+i64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::I64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } )))));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U8>();
+u8 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U8(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } )))));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U16>();
+u16 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U16(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } )))));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U32>();
+u32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U32(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } )))));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::U64>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::U64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } )))));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::USize>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::USize(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } )))));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::F32>();
+f32 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::F32(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::F32() } )))));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::F64>();
+f64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::NumericConstant>( types::CheckedNumericConstant { typename types::CheckedNumericConstant::F64(val) } ,span,types::builtin( types::BuiltinType { typename types::BuiltinType::F64() } )))));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::UnknownSigned>();
+i64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).infer_signed_int(val,span,type_hint_unwrapped)))));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::NumericConstant::UnknownUnsigned>();
+u64 const& val = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((((*this).infer_unsigned_int(val,span,type_hint_unwrapped)))));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)); goto __jakt_label_435;
+
+}
+__jakt_label_435:; __jakt_var_493.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::SingleQuotedString>();DeprecatedString const& val = __jakt_match_value.val;
+JaktInternal::Optional<DeprecatedString> const& prefix = __jakt_match_value.prefix;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = (prefix.value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }));
+if (__jakt_enum_value == Jakt::DeprecatedString(""sv)) {
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::CharacterConstant>(val,span))));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("b"sv)) {
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::ByteConstant>(val,span))));
+}
+else if (__jakt_enum_value == Jakt::DeprecatedString("c"sv)) {
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::CCharacterConstant>(val,span))));
+}
+else {
+{
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("Unknown string prefix {}"sv),prefix)))))));
+}
+}
+}()))
+);
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::QuotedString>();DeprecatedString const& val = __jakt_match_value.val;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_494; {
+if (((*this).dump_try_hints)){
+TRY((((*this).dump_try_hint(span))));
+}
+__jakt_var_494 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = ((((type_hint).has_value()) && (!((((type_hint.value())).equals(types::unknown_type_id()))))));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_495; {
+types::TypeId type_id = TRY((((*this).strip_optional_from_type(TRY((((((*this).generic_inferences)).map((type_hint.value())))))))));
+bool may_throw = true;
+if (((!(((type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ))))) && ((((*this).get_type(type_id)))->is_concrete()))){
+JaktInternal::Optional<typechecker::TraitImplementationDescriptor> const trait_implementation = TRY((((*this).find_any_singular_trait_implementation(type_id,(TRY((DynamicArray<DeprecatedString>::create_with({Jakt::DeprecatedString("FromStringLiteral"sv), Jakt::DeprecatedString("ThrowingFromStringLiteral"sv)})))),scope_id,span))));
+if ((!(((trait_implementation).has_value())))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Type {} cannot be used as an overloaded string literal type"sv),TRY((((*this).type_name(type_id,false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("Consider implementing the FromStringLiteral trait for {}"sv),TRY((((*this).type_name(type_id,false))))))),span))));
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+}
+else {
+(may_throw = ((((trait_implementation.value())).trait_name) == Jakt::DeprecatedString("ThrowingFromStringLiteral"sv)));
+}
+
+}
+else if ((!(((((*this).get_type(type_id)))->is_concrete())))){
+(type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
+}
+TRY((((*this).unify((type_hint.value()),span,type_id,span))));
+__jakt_var_495 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::QuotedString>(types::CheckedStringLiteral( types::StringLiteral { typename types::StringLiteral::Static(val) } ,type_id,may_throw),span))); goto __jakt_label_437;
+
+}
+__jakt_label_437:; __jakt_var_495.release_value(); }));
+}
+else {
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::QuotedString>(types::CheckedStringLiteral( types::StringLiteral { typename types::StringLiteral::Static(val) } ,types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ),true),span))));
+}
+}()))
+; goto __jakt_label_436;
+
+}
+__jakt_label_436:; __jakt_var_494.release_value(); }));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Call>();parser::ParsedCall const& call = __jakt_match_value.call;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_496; {
+__jakt_var_496 = TRY((((*this).typecheck_call(call,scope_id,span,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),safety_mode,type_hint,false)))); goto __jakt_label_438;
+
+}
+__jakt_label_438:; __jakt_var_496.release_value(); }));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::MethodCall>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+parser::ParsedCall const& call = __jakt_match_value.call;
+utility::Span const& span = __jakt_match_value.span;
+bool const& is_optional = __jakt_match_value.is_optional;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_497; {
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+types::TypeId const checked_expr_type_id = ((checked_expr)->type());
+bool found_optional = false;
+JaktInternal::Optional<types::StructLikeId> const parent_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(TRY((((*this).final_type_resolution_form(checked_expr_type_id,scope_id))))));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),id) } ));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),id) } ));
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("String"sv)))))) } ));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::StructLikeId>> __jakt_var_498; {
+__jakt_var_498 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = (is_optional);
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::StructLikeId>> __jakt_var_499; {
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+JaktInternal::Optional<types::StructLikeId> struct_id = JaktInternal::OptionalNone();
+if ((!(((id).equals(optional_struct_id))))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Can't use ‘{}’ as an optional type in optional chained call"sv),((((*this).get_struct(id))).name)))),span))));
+}
+else {
+(found_optional = true);
+(struct_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(((args)[static_cast<i64>(0LL)])));
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } );
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue( types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } );
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),id) } );
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue( types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),id) } );
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<types::StructLikeId> __jakt_var_500; {
+TRY((((*this).error(Jakt::DeprecatedString("Can't use non-struct type as an optional type in optional chained call"sv),span))));
+(found_optional = false);
+__jakt_var_500 =  types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),optional_struct_id) } ; goto __jakt_label_442;
+
+}
+__jakt_label_442:; __jakt_var_500.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+}
+
+__jakt_var_499 = static_cast<JaktInternal::Optional<types::StructLikeId>>(struct_id.value_or_lazy_evaluated([&] { return  types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),optional_struct_id) } ; })); goto __jakt_label_441;
+
+}
+__jakt_label_441:; __jakt_var_499.release_value(); }));
+}
+else {
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Struct(args,id) } ));
+}
+}()))
+; goto __jakt_label_440;
+
+}
+__jakt_label_440:; __jakt_var_498.release_value(); }));
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Enum(args,id) } ));
+};/*case end*/
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
+types::TraitId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Trait(JaktInternal::OptionalNone(),id) } ));
 };/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
 JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-{
-if (is_optional){
-TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on non-optional types"sv),span))));
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Trait(args,id) } ));
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::TypeVariable>();JaktInternal::DynamicArray<types::TypeId> const& trait_implementations = __jakt_match_value.trait_implementations;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = (((trait_implementations).size()));
+if (__jakt_enum_value == static_cast<size_t>(0ULL)) {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
 }
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-ScopeGuard __jakt_var_532([&] {
-((((*this).generic_inferences)).restore(checkpoint));
-});
-TRY((((*this).map_generic_arguments(checked_expr_type_id,args))));
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-{
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::StructLikeId>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(((trait_implementations)[static_cast<i64>(0LL)])));
+switch(__jakt_match_variant.index()) {
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
+types::TraitId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Trait(JaktInternal::OptionalNone(),id) } ));
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::StructLikeId>>( types::StructLikeId { typename types::StructLikeId::Trait(args,id) } ));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
-types::CheckedField field = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
-if ((((member)->name) == field_name)){
-types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
-if (is_optional){
-(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+}()))
+);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<types::StructLikeId> __jakt_var_501; {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("no methods available on value (type: {} {})"sv),((((*this).get_type(checked_expr_type_id)))->constructor_name()),TRY((((*this).type_name(checked_expr_type_id,false))))))),((checked_expr)->span())))));
+__jakt_var_501 = JaktInternal::OptionalNone(); goto __jakt_label_443;
+
 }
-TRY((((*this).check_member_access(scope_id,((enum_).scope_id),member,span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedCommonEnumMember>(checked_expr,field_name,span,is_optional,resolved_type_id))));
+__jakt_label_443:; __jakt_var_501; }));
+};/*case end*/
+}/*switch end*/
+}()
+));
+if ((is_optional && (!(found_optional)))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Optional chain mismatch: expected optional chain, found {}"sv),TRY((((*this).type_name(checked_expr_type_id,false))))))),((checked_expr)->span())))));
 }
+NonnullRefPtr<typename types::CheckedExpression> const checked_call_expr = TRY((((*this).typecheck_call(call,scope_id,span,checked_expr,parent_id,safety_mode,type_hint,false))));
+types::TypeId const type_id = ((checked_call_expr)->type());
+__jakt_var_497 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *checked_call_expr;
+switch(__jakt_match_variant.index()) {
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_502; {
+types::TypeId result_type = ((call).return_type);
+if (is_optional){
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+(result_type = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({result_type}))))))))))));
 }
+__jakt_var_502 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::MethodCall>(checked_expr,call,span,is_optional,result_type))); goto __jakt_label_444;
 
 }
+__jakt_label_444:; __jakt_var_502.release_value(); }));
+};/*case end*/
+default: {
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("typecheck_call should return `CheckedExpression::Call()`"sv)))));
 }
+};/*case end*/
+}/*switch end*/
+}()
+)); goto __jakt_label_439;
 
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown common member of enum: {}.{}"sv),((enum_).name),field_name))),span))));
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_439:; __jakt_var_497.release_value(); }));
 };/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-JaktInternal::DynamicArray<types::TypeId> const args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-{
-if (is_optional){
-TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on non-optional types"sv),span))));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Range>();JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& from = __jakt_match_value.from;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& to = __jakt_match_value.to;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_503; {
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_from = JaktInternal::OptionalNone();
+JaktInternal::Optional<types::TypeId> from_type = JaktInternal::OptionalNone();
+utility::Span from_span = span;
+if ((((from).has_value()) && ((!((((from.value()))->index() == 1 /* NumericConstant */))) && (!((((from.value()))->index() == 1 /* NumericConstant */)))))){
+(checked_from = TRY((((*this).typecheck_expression((from.value()),scope_id,safety_mode,JaktInternal::OptionalNone())))));
+(from_type = (((checked_from.value()))->type()));
+(from_span = (((checked_from.value()))->span()));
 }
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
-ScopeGuard __jakt_var_533([&] {
-((((*this).generic_inferences)).restore(checkpoint));
-});
-TRY((((*this).map_generic_arguments(checked_expr_type_id,args))));
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-{
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_to = JaktInternal::OptionalNone();
+types::TypeId to_type = types::unknown_type_id();
+utility::Span to_span = span;
+if (((to).has_value())){
+(checked_to = TRY((((*this).typecheck_expression((to.value()),scope_id,safety_mode,from_type)))));
+(to_type = (((checked_to.value()))->type()));
+(to_span = (((checked_to.value()))->span()));
 }
-types::CheckedField field = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
-if ((((member)->name) == field_name)){
-types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
-if (is_optional){
-(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+if ((((from).has_value()) && ((((from.value()))->index() == 1 /* NumericConstant */) || (((from.value()))->index() == 1 /* NumericConstant */)))){
+(checked_from = TRY((((*this).typecheck_expression((from.value()),scope_id,safety_mode,to_type)))));
+(from_type = (((checked_from.value()))->type()));
+(from_span = (((checked_from.value()))->span()));
 }
-TRY((((*this).check_member_access(scope_id,((enum_).scope_id),member,span))));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedCommonEnumMember>(checked_expr,field_name,span,is_optional,resolved_type_id))));
+JaktInternal::Optional<types::TypeId> values_type_id = JaktInternal::OptionalNone();
+if ((((from).has_value()) && ((to).has_value()))){
+(values_type_id = TRY((((*this).unify((from_type.value()),from_span,to_type,from_span)))));
+if ((!(((values_type_id).has_value())))){
+TRY((((*this).error(Jakt::DeprecatedString("Range values differ in types"sv),span))));
 }
 }
-
+else if (((from).has_value())){
+(values_type_id = from_type);
 }
+else if (((to).has_value())){
+(values_type_id = to_type);
 }
+types::StructId const range_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Range"sv)))));
+NonnullRefPtr<typename types::Type> const range_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(range_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({((values_type_id).value_or(types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } )))})))))));
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(range_type))));
+__jakt_var_503 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Range>(checked_from,checked_to,span,type_id))); goto __jakt_label_445;
 
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown common member of enum: {}.{}"sv),((enum_).name),field_name))),span))));
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_445:; __jakt_var_503.release_value(); }));
+};/*case end*/
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Reflect>();NonnullRefPtr<typename parser::ParsedType> const& type = __jakt_match_value.type;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_504; {
+types::EnumId const reflected_type_enum_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = TRY((((((*this).program))->find_reflected_primitive(Jakt::DeprecatedString("Type"sv)))));
+switch(__jakt_match_variant.index()) {
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructOrEnumId::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(id);
 };/*case end*/
 default: {
-return (TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Member field access on value of non-struct type ‘{}’"sv),TRY((((*this).type_name(checked_expr_type_id,false))))))),span))))), JaktInternal::ExplicitValue<void>();
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("unreachable"sv)))));
+}
 };/*case end*/
 }/*switch end*/
 }()
 ));
-return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,types::unknown_type_id()))));
-}
+types::TypeId const reflected_type = TRY((((*this).typecheck_typename(type,scope_id,JaktInternal::OptionalNone()))));
+__jakt_var_504 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Reflect>(reflected_type,span,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(reflected_type_enum_id)))))))))); goto __jakt_label_446;
+
 }
+__jakt_label_446:; __jakt_var_504.release_value(); }));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::UnaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+parser::UnaryOperator const& op = __jakt_match_value.op;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_505; {
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 5: {
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,JaktInternal::OptionalNone())))));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span)))));
+};/*case end*/
+}/*switch end*/
+}()
+));
+types::CheckedUnaryOperator const checked_op = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedUnaryOperator, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::PreIncrement() } );
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::PostIncrement() } );
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::PreDecrement() } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::PostDecrement() } );
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Negate() } );
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Dereference() } );
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::RawAddress() } );
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Reference() } );
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::MutableReference() } );
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::LogicalNot() } );
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue( types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::BitwiseNot() } );
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::TypeCast>();
+parser::TypeCast const& cast = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::CheckedUnaryOperator> __jakt_var_506; {
+types::TypeId const type_id = TRY((((*this).typecheck_typename(((cast).parsed_type()),scope_id,JaktInternal::OptionalNone()))));
+types::CheckedTypeCast const checked_cast = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::CheckedTypeCast, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = cast;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(({ Optional<types::CheckedTypeCast> __jakt_var_507; {
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+NonnullRefPtr<typename types::Type> const optional_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({type_id})))))));
+types::TypeId const optional_type_id = TRY((((*this).find_or_add_type_id(optional_type))));
+__jakt_var_507 =  types::CheckedTypeCast { typename types::CheckedTypeCast::Fallible(optional_type_id) } ; goto __jakt_label_449;
 
-ErrorOr<types::FunctionId> typechecker::Typechecker::typecheck_function_predecl(parser::ParsedFunction const parsed_function,types::ScopeId const parent_scope_id,JaktInternal::Optional<types::TypeId> const this_arg_type_id,JaktInternal::Optional<NonnullRefPtr<types::FunctionGenerics>> generics) {
-{
-types::ScopeId const function_scope_id = TRY((((*this).create_scope(parent_scope_id,((parsed_function).can_throw),TRY((__jakt_format(Jakt::DeprecatedString("fn({})"sv),((parsed_function).name)))),true))));
-DeprecatedString const scope_debug_name = TRY((__jakt_format(Jakt::DeprecatedString("function-block({})"sv),((parsed_function).name))));
-types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,((parsed_function).can_throw),scope_debug_name,true))));
-size_t const module_id = ((((*this).current_module_id)).id);
-bool base_definition = false;
-if ((!(((generics).has_value())))){
-(generics = TRY((types::FunctionGenerics::__jakt_create(function_scope_id,(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))));
-(base_definition = true);
 }
-bool const is_generic_function = (!(((((parsed_function).generic_parameters)).is_empty())));
-bool const is_generic = (is_generic_function || (((this_arg_type_id).has_value()) && ((((*this).get_type((this_arg_type_id.value()))))->index() == 19 /* GenericInstance */)));
-NonnullRefPtr<types::CheckedFunction> checked_function = TRY((types::CheckedFunction::__jakt_create(((parsed_function).name),((parsed_function).name_span),TRY((((*this).typecheck_visibility(((parsed_function).visibility),parent_scope_id)))),types::unknown_type_id(),((parsed_function).return_type_span),(TRY((DynamicArray<types::CheckedParameter>::create_with({})))),(generics.value()),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false),((parsed_function).can_throw),((parsed_function).type),((parsed_function).linkage),function_scope_id,JaktInternal::OptionalNone(),((!(is_generic)) || (!(base_definition))),parsed_function,((parsed_function).is_comptime),false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),((parsed_function).external_name),((parsed_function).deprecated_message),JaktInternal::OptionalNone())));
-NonnullRefPtr<types::Module> current_module = ((*this).current_module());
-types::FunctionId const function_id = TRY((((current_module)->add_function(checked_function))));
-types::ScopeId const checked_function_scope_id = ((checked_function)->function_scope_id);
-bool const external_linkage = ((((parsed_function).linkage)).index() == 1 /* External */);
-JaktInternal::Optional<types::ScopeId> const check_scope = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::ScopeId>,ErrorOr<types::FunctionId>>{
-auto __jakt_enum_value = ((is_generic || ((((parsed_function).return_type))->index() == 13 /* Empty */)));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<types::ScopeId>>(TRY((((*this).create_scope(parent_scope_id,((parsed_function).can_throw),scope_debug_name,true))))));
+__jakt_label_449:; __jakt_var_507.release_value(); }));
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue( types::CheckedTypeCast { typename types::CheckedTypeCast::Infallible(type_id) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+__jakt_var_506 =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::TypeCast(checked_cast) } ; goto __jakt_label_448;
+
 }
-else {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+__jakt_label_448:; __jakt_var_506.release_value(); }));
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Sizeof>();
+NonnullRefPtr<typename parser::ParsedType> const& unchecked_type = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::CheckedUnaryOperator> __jakt_var_508; {
+types::TypeId const type_id = TRY((((*this).typecheck_typename(unchecked_type,scope_id,JaktInternal::OptionalNone()))));
+__jakt_var_508 =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Sizeof(type_id) } ; goto __jakt_label_450;
+
 }
-}()))
-;
-i64 i = static_cast<i64>(0LL);
+__jakt_label_450:; __jakt_var_508.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::UnaryOperator::Is>();
+NonnullRefPtr<typename parser::ParsedType> const& unchecked_type = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<types::CheckedUnaryOperator> __jakt_var_509; {
+bool const old_ignore_errors = ((*this).ignore_errors);
+(((*this).ignore_errors) = true);
+types::TypeId const type_id = TRY((((*this).typecheck_typename(unchecked_type,scope_id,JaktInternal::OptionalNone()))));
+(((*this).ignore_errors) = old_ignore_errors);
+(((*this).had_an_error) = false);
+types::CheckedUnaryOperator operator_is =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::Is(type_id) } ;
+if (((unchecked_type)->index() == 0 /* Name */)){
+DeprecatedString const name = ((unchecked_type)->get<parser::ParsedType::Name>()).name;
+types::TypeId const expr_type_id = ((checked_expr)->type());
+if (((((*this).get_type(expr_type_id)))->index() == 24 /* Enum */)){
+types::EnumId const enum_id = ((((*this).get_type(expr_type_id)))->get<types::Type::Enum>()).value;
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+bool exists = false;
 {
-JaktInternal::ArrayIterator<parser::ParsedGenericParameter> _magic = ((((parsed_function).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<types::CheckedEnumVariant> _magic = ((((enum_).variants)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedEnumVariant> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedGenericParameter generic_parameter = (_magic_value.value());
+types::CheckedEnumVariant variant = (_magic_value.value());
 {
-types::TypeId type_var_type_id = types::TypeId(((current_module)->id),((((current_module)->types)).size()));
-if (base_definition){
-types::FunctionGenericParameter parameter = TRY((types::FunctionGenericParameter::parameter(type_var_type_id,((generic_parameter).span))));
-JaktInternal::DynamicArray<types::TypeId> trait_implementations = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((((current_module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(((generic_parameter).name),trait_implementations)))))));
-if (((((generic_parameter).requires_list)).has_value())){
-TRY((((*this).fill_trait_requirements((((generic_parameter).requires_list).value()),((((((parameter).checked_parameter)).constraints))),((trait_implementations)),parent_scope_id))));
-}
-TRY((((((((checked_function)->generics))->params)).push(parameter))));
-}
-else if (((((((((((checked_function)->generics))->params))[i])).kind)).index() == 1 /* Parameter */)){
-(type_var_type_id = ((((((((checked_function)->generics))->params))[i])).type_id()));
-}
-if (((!(((parsed_function).must_instantiate))) || external_linkage)){
-TRY((((*this).add_type_to_scope(checked_function_scope_id,((generic_parameter).name),type_var_type_id,((generic_parameter).span)))));
-}
-if (((check_scope).has_value())){
-TRY((((*this).add_type_to_scope((check_scope.value()),((generic_parameter).name),type_var_type_id,((generic_parameter).span)))));
+(exists = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = variant;
+switch(__jakt_match_variant.index()) {
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& var_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue((var_name == name));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& var_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue((var_name == name));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& var_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue((var_name == name));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& var_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue((var_name == name));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+if (exists){
+(operator_is =  types::CheckedUnaryOperator { typename types::CheckedUnaryOperator::IsEnumVariant(variant,(TRY((DynamicArray<types::CheckedEnumVariantBinding>::create_with({})))),expr_type_id) } );
+break;
 }
-((i++));
 }
 
 }
 }
 
-bool first = true;
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-{
-JaktInternal::ArrayIterator<parser::ParsedParameter> _magic = ((((parsed_function).params)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((!(exists)) && ((type_id).equals(types::unknown_type_id())))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist on {}"sv),name,TRY((((*this).type_name(expr_type_id,false))))))),span))));
 }
-parser::ParsedParameter parameter = (_magic_value.value());
-{
-types::CheckedParameter const checked_param = TRY((((*this).typecheck_parameter(parameter,checked_function_scope_id,first,this_arg_type_id,check_scope))));
-TRY((((((checked_function)->params)).push(checked_param))));
-if (base_definition){
-TRY((((((((checked_function)->generics))->base_params)).push(checked_param))));
 }
-(first = false);
+else if (((type_id).equals(types::unknown_type_id()))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),name))),span))));
 }
-
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("The right-hand side of an `is` operator must be a type name or enum variant"sv),span))));
 }
 
-if (((((parsed_function).stores_arguments)).has_value())){
-{
-JaktInternal::ArrayIterator<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> _magic = (((((parsed_function).stores_arguments).value())).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel> index_____ = (_magic_value.value());
-{
-JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel> const jakt__index_____ = index_____;
-size_t const index = ((jakt__index_____).template get<0>());
-parser::ArgumentStoreLevel const _ = ((jakt__index_____).template get<1>());
+__jakt_var_509 = operator_is; goto __jakt_label_451;
 
-if ((index >= ((((checked_function)->params)).size()))){
-TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("stores_argument() index out of bounds"sv)))));
-}
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<types::FunctionId>>{
-auto&& __jakt_match_variant = *((*this).get_type(((((((((checked_function)->params))[index])).variable))->type_id)));
-switch(__jakt_match_variant.index()) {
-case 27: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 28: {
-{
 }
-return JaktInternal::ExplicitValue<void>();
+__jakt_label_451:; __jakt_var_509.release_value(); }));
 };/*case end*/
-default: {
-{
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("This parameter is not a reference"sv),((((((((checked_function)->params))[index])).variable))->definition_span),Jakt::DeprecatedString("stores_argument() may only be used to declare reference lifetime requirements"sv),((((((((checked_function)->params))[index])).variable))->definition_span)))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::UnaryOperator::IsEnumVariant>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const& bindings = __jakt_match_value.bindings;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_is_enum_variant(checked_expr,inner,bindings,scope_id)))));
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 ));
+__jakt_var_505 = TRY((((*this).typecheck_unary_operation(checked_expr,checked_op,span,scope_id,safety_mode)))); goto __jakt_label_447;
+
+}
+__jakt_label_447:; __jakt_var_505.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::BinaryOp>();NonnullRefPtr<typename parser::ParsedExpression> const& lhs = __jakt_match_value.lhs;
+parser::BinaryOperator const& op = __jakt_match_value.op;
+NonnullRefPtr<typename parser::ParsedExpression> const& rhs = __jakt_match_value.rhs;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_510; {
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> original_checked_lhs = JaktInternal::OptionalNone();
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> original_checked_rhs = JaktInternal::OptionalNone();
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_lhs = JaktInternal::OptionalNone();
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> checked_rhs = JaktInternal::OptionalNone();
+if ((((lhs)->index() == 1 /* NumericConstant */) || ((lhs)->index() == 1 /* NumericConstant */))){
+(original_checked_rhs = TRY((((*this).typecheck_expression(rhs,scope_id,safety_mode,JaktInternal::OptionalNone())))));
+(checked_rhs = TRY((((*this).dereference_if_needed((original_checked_rhs.value()),span)))));
+types::TypeId const hint = (((checked_rhs.value()))->type());
+(original_checked_lhs = TRY((((*this).typecheck_expression(lhs,scope_id,safety_mode,hint)))));
+(checked_lhs = TRY((((*this).dereference_if_needed((original_checked_lhs.value()),span)))));
+}
+else {
+(original_checked_lhs = TRY((((*this).typecheck_expression(lhs,scope_id,safety_mode,JaktInternal::OptionalNone())))));
+(checked_lhs = TRY((((*this).dereference_if_needed((original_checked_lhs.value()),span)))));
+types::TypeId const hint = (((checked_lhs.value()))->type());
+(original_checked_rhs = TRY((((*this).typecheck_expression(rhs,scope_id,safety_mode,hint)))));
+(checked_rhs = TRY((((*this).dereference_if_needed((original_checked_rhs.value()),span)))));
 }
 
+if ((TRY((((*this).type_contains_reference((((original_checked_lhs.value()))->type()))))) && ((rhs)->index() == 11 /* UnaryOp */))){
+parser::UnaryOperator const op = ((rhs)->get<parser::ParsedExpression::UnaryOp>()).op;
+if ((((op).index() == 7 /* Reference */) || ((op).index() == 8 /* MutableReference */))){
+TRY((((*this).error_with_hint(Jakt::DeprecatedString("Attempt to rebind a reference will result in write-through"sv),span,Jakt::DeprecatedString("This reference will be immediately dereferenced and then assigned"sv),((rhs)->span())))));
 }
 }
+types::TypeId const output_type = TRY((((*this).typecheck_binary_operation((checked_lhs.value()),op,(checked_rhs.value()),scope_id,span))));
+__jakt_var_510 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::BinaryOp>((checked_lhs.value()),op,(checked_rhs.value()),span,output_type))); goto __jakt_label_452;
 
 }
-(((checked_function)->stores_arguments) = ((parsed_function).stores_arguments));
-types::TypeId function_return_type_id = TRY((((*this).typecheck_typename(((parsed_function).return_type),checked_function_scope_id,JaktInternal::OptionalNone()))));
-if (((((parsed_function).return_type))->index() == 13 /* Empty */)){
-if (((parsed_function).is_fat_arrow)){
-bool const old_ignore_errors = ((*this).ignore_errors);
-(((*this).ignore_errors) = true);
-types::CheckedBlock const block = TRY((((*this).typecheck_block(((parsed_function).block),(check_scope.value()), types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
-if (((*this).had_an_error)){
-(function_return_type_id = types::void_type_id());
-(((*this).ignore_errors) = false);
-TRY((((*this).error_with_hint(Jakt::DeprecatedString("Can't infer the return type of this function"sv),((parsed_function).return_type_span),Jakt::DeprecatedString("Try adding an explicit return type to the function here"sv),((parsed_function).return_type_span)))));
+__jakt_label_452:; __jakt_var_510.release_value(); }));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedExpression::OptionalNone>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_511; {
+JaktInternal::Optional<types::TypeId> type_hint_unwrapped = type_hint;
+if ((((type_hint).has_value()) && ((((*this).get_type((type_hint.value()))))->index() == 19 /* GenericInstance */))){
+types::StructId const id = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).args;
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+if (((id).equals(optional_struct_id))){
+(type_hint_unwrapped = ((args)[static_cast<i64>(0LL)]));
 }
-else {
-(function_return_type_id = ((*this).infer_function_return_type(block)));
 }
+__jakt_var_511 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::OptionalNone>(span,type_hint_unwrapped.value_or_lazy_evaluated([&] { return types::unknown_type_id(); })))); goto __jakt_label_453;
 
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
-}
-else {
-(function_return_type_id = types::void_type_id());
 }
+__jakt_label_453:; __jakt_var_511.release_value(); }));
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::OptionalSome>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_512; {
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression(expr,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+types::TypeId const type_id = ((checked_expr)->type());
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+NonnullRefPtr<typename types::Type> const optional_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({type_id})))))));
+types::TypeId const optional_type_id = TRY((((*this).find_or_add_type_id(optional_type))));
+__jakt_var_512 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::OptionalSome>(checked_expr,span,optional_type_id))); goto __jakt_label_454;
 
 }
-(((checked_function)->return_type_id) = function_return_type_id);
-TRY((((*this).check_that_type_doesnt_contain_reference(function_return_type_id,((parsed_function).return_type_span)))));
-if (((!(((((parsed_function).generic_parameters)).is_empty()))) && ((function_return_type_id).equals(types::unknown_type_id())))){
-bool const old_ignore_errors = ((*this).ignore_errors);
-(((*this).ignore_errors) = true);
-types::CheckedBlock const block = TRY((((*this).typecheck_block(((parsed_function).block),(check_scope.value()), types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
-types::TypeId const return_type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId,ErrorOr<types::FunctionId>>{
-auto __jakt_enum_value = (((function_return_type_id).equals(types::unknown_type_id())));
+__jakt_label_454:; __jakt_var_512.release_value(); }));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Var>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+{
+JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const var = TRY((((*this).find_var_in_scope(scope_id,name))));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>,ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto __jakt_enum_value = (((var).has_value()));
 if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(((*this).infer_function_return_type(block)));
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Var>((var.value()),span))));
 }
 else {
-return JaktInternal::ExplicitValue(TRY((((*this).resolve_type_var(function_return_type_id,parent_scope_id)))));
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_513; {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Variable '{}' not found"sv),name))),span))));
+__jakt_var_513 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Var>(TRY((types::CheckedVariable::__jakt_create(name,((type_hint).value_or(types::unknown_type_id())),false,span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone()))),span))); goto __jakt_label_455;
+
+}
+__jakt_label_455:; __jakt_var_513.release_value(); }));
 }
 }()))
-;
-(((checked_function)->block) = block);
-(((checked_function)->return_type_id) = return_type_id);
+);
 }
-TRY((((*this).add_function_to_scope(parent_scope_id,((parsed_function).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((parsed_function).name_span)))));
-return (function_id);
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::ForcedUnwrap>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_514; {
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+NonnullRefPtr<typename types::Type> const type = ((*this).get_type(((checked_expr)->type())));
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+types::StructId const weakptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+types::TypeId const type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *type;
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_515; {
+types::TypeId inner_type_id = types::unknown_type_id();
+if ((((id).equals(optional_struct_id)) || ((id).equals(weakptr_struct_id)))){
+(inner_type_id = ((args)[static_cast<i64>(0LL)]));
 }
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Forced unwrap only works on Optional"sv),span))));
 }
 
-ErrorOr<bool> typechecker::Typechecker::type_contains_reference(types::TypeId const type_id) {
-{
-NonnullRefPtr<typename types::Type> const type = ((*this).get_type(type_id));
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, ErrorOr<bool>>{
-auto&& __jakt_match_variant = *type;
-switch(__jakt_match_variant.index()) {
-case 27: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 28: {
-return JaktInternal::ExplicitValue(true);
+__jakt_var_515 = inner_type_id; goto __jakt_label_457;
+
+}
+__jakt_label_457:; __jakt_var_515.release_value(); }));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(false);
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_516; {
+TRY((((*this).error(Jakt::DeprecatedString("Forced unwrap only works on Optional"sv),span))));
+__jakt_var_516 = types::unknown_type_id(); goto __jakt_label_458;
+
+}
+__jakt_label_458:; __jakt_var_516.release_value(); }));
 };/*case end*/
 }/*switch end*/
 }()
-)));
-}
-}
+));
+__jakt_var_514 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::ForcedUnwrap>(checked_expr,span,type_id))); goto __jakt_label_456;
 
-ErrorOr<types::ModuleId> typechecker::Typechecker::create_module(DeprecatedString const name,bool const is_root,JaktInternal::Optional<DeprecatedString> const path) {
-{
-size_t const new_id = ((((((*this).program))->modules)).size());
-types::ModuleId const module_id = types::ModuleId(new_id);
-NonnullRefPtr<types::Module> const module = TRY((types::Module::__jakt_create(module_id,name,(TRY((DynamicArray<NonnullRefPtr<types::CheckedFunction>>::create_with({})))),(TRY((DynamicArray<types::CheckedStruct>::create_with({})))),(TRY((DynamicArray<types::CheckedEnum>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<types::Scope>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<typename types::Type>>::create_with({TRY((types::Type::template __jakt_create<typename types::Type::Void>())), TRY((types::Type::template __jakt_create<typename types::Type::Bool>())), TRY((types::Type::template __jakt_create<typename types::Type::U8>())), TRY((types::Type::template __jakt_create<typename types::Type::U16>())), TRY((types::Type::template __jakt_create<typename types::Type::U32>())), TRY((types::Type::template __jakt_create<typename types::Type::U64>())), TRY((types::Type::template __jakt_create<typename types::Type::I8>())), TRY((types::Type::template __jakt_create<typename types::Type::I16>())), TRY((types::Type::template __jakt_create<typename types::Type::I32>())), TRY((types::Type::template __jakt_create<typename types::Type::I64>())), TRY((types::Type::template __jakt_create<typename types::Type::F32>())), TRY((types::Type::template __jakt_create<typename types::Type::F64>())), TRY((types::Type::template __jakt_create<typename types::Type::Usize>())), TRY((types::Type::template __jakt_create<typename types::Type::JaktString>())), TRY((types::Type::template __jakt_create<typename types::Type::CChar>())), TRY((types::Type::template __jakt_create<typename types::Type::CInt>())), TRY((types::Type::template __jakt_create<typename types::Type::Unknown>())), TRY((types::Type::template __jakt_create<typename types::Type::Never>()))})))),(TRY((DynamicArray<NonnullRefPtr<types::CheckedTrait>>::create_with({})))),(TRY((DynamicArray<NonnullRefPtr<types::CheckedVariable>>::create_with({})))),(TRY((DynamicArray<types::ModuleId>::create_with({})))),path.value_or_lazy_evaluated([&] { return (((((((*this).compiler))->current_file_path()).value())).to_string()); }),is_root)));
-TRY((((((((*this).program))->modules)).push(module))));
-return (module_id);
 }
-}
-
-ErrorOr<void> typechecker::Typechecker::set_owner_scope_if_needed(types::ScopeId const parent_scope_id,JaktInternal::DynamicArray<types::FunctionId> const overload_set) {
-{
+__jakt_label_456:; __jakt_var_514.release_value(); }));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& values = __jakt_match_value.values;
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const& fill_size = __jakt_match_value.fill_size;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_array(scope_id,values,fill_size,span,safety_mode,type_hint)))));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& values = __jakt_match_value.values;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_517; {
+types::TypeId const VOID_TYPE_ID = types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } );
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> checked_values = (TRY((DynamicArray<NonnullRefPtr<typename types::CheckedExpression>>::create_with({}))));
+JaktInternal::DynamicArray<types::TypeId> checked_types = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedExpression>> _magic = ((values).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::FunctionId overload = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedExpression> value = (_magic_value.value());
 {
-NonnullRefPtr<types::CheckedFunction> function = ((*this).get_function(overload));
-if ((!(((((function)->owner_scope)).has_value())))){
-(((function)->owner_scope) = parent_scope_id);
-}
-}
-
-}
-}
-
+NonnullRefPtr<typename types::CheckedExpression> const checked_value = TRY((((*this).typecheck_expression(value,scope_id,safety_mode,JaktInternal::OptionalNone()))));
+types::TypeId const type_id = ((checked_value)->type());
+if (((type_id).equals(VOID_TYPE_ID))){
+TRY((((*this).error(Jakt::DeprecatedString("Cannot create a tuple that contains a value of type void"sv),((value)->span())))));
 }
-return {};
+TRY((((checked_types).push(type_id))));
+TRY((((checked_values).push(checked_value))));
 }
 
-ErrorOr<void> typechecker::Typechecker::set_owner_scope_if_needed(types::ScopeId const parent_scope_id,types::VarId const var_id) {
-{
-NonnullRefPtr<types::CheckedVariable> variable = ((*this).get_variable(var_id));
-if ((!(((((variable)->owner_scope)).has_value())))){
-(((variable)->owner_scope) = parent_scope_id);
-}
 }
-return {};
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_namespace_function_predecl(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
-{
-JaktInternal::DynamicArray<types::ScopeId> const children = ((TRY((((*this).get_scope(scope_id)))))->children);
+if ((((type_hint).has_value()) && ((((*this).get_type((type_hint.value()))))->index() == 19 /* GenericInstance */))){
+types::StructId const id = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type((type_hint.value()))))->get<types::Type::GenericInstance>()).args;
+if ((((checked_types).size()) == ((args).size()))){
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((parsed_namespace).namespaces)).size()))});
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((args).size()))});
 for (;;){
 JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
@@ -12125,679 +12089,721 @@ break;
 }
 size_t i = (_magic_value.value());
 {
-parser::ParsedNamespace const child_namespace = ((((parsed_namespace).namespaces))[i]);
-types::ScopeId const child_namespace_scope_id = ((children)[i]);
-TRY((((*this).typecheck_namespace_function_predecl(child_namespace,child_namespace_scope_id))));
+types::TypeId value_type = ((checked_types)[i]);
+JaktInternal::Optional<types::TypeId> const unified = TRY((((*this).unify(((args)[i]),span,value_type,span))));
+if (((unified).has_value())){
+bool type_optional = false;
+if (((((*this).get_type((unified.value()))))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type((unified.value()))))->get<types::Type::GenericInstance>()).id;
+if (((id).equals(optional_struct_id))){
+(type_optional = true);
+}
+}
+bool value_optional = false;
+if (((((*this).get_type(value_type)))->index() == 19 /* GenericInstance */)){
+types::StructId const id = ((((*this).get_type(value_type)))->get<types::Type::GenericInstance>()).id;
+if (((id).equals(optional_struct_id))){
+(value_optional = true);
+}
+}
+(((checked_types)[i]) = (unified.value()));
+if ((type_optional && ((!(value_optional)) && (!(((((checked_values)[i]))->index() == 26 /* OptionalSome */)))))){
+if ((((((checked_values)[i]))->index() == 25 /* OptionalNone */) && ((((*this).get_type((unified.value()))))->index() == 19 /* GenericInstance */))){
+types::StructId const id = ((((*this).get_type((unified.value()))))->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const args = ((((*this).get_type((unified.value()))))->get<types::Type::GenericInstance>()).args;
+(value_type = ((args)[static_cast<i64>(0LL)]));
+}
+NonnullRefPtr<typename types::Type> const optional_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({value_type})))))));
+types::TypeId const optional_type_id = TRY((((*this).find_or_add_type_id(optional_type))));
+(((checked_values)[i]) = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::OptionalSome>(((checked_values)[i]),span,optional_type_id))));
 }
-
 }
 }
 
-{
-JaktInternal::ArrayIterator<parser::ParsedFunction> _magic = ((((parsed_namespace).functions)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedFunction> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedFunction fun = (_magic_value.value());
-{
-TRY((((*this).typecheck_function_predecl(fun,scope_id,JaktInternal::OptionalNone(),JaktInternal::OptionalNone()))));
 }
 
 }
 }
+types::StructId const tuple_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
+types::TypeId const type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(tuple_struct_id,checked_types)))))));
+if (((type_hint).has_value())){
+TRY((((*this).check_types_for_compat((type_hint.value()),type_id,((((*this).generic_inferences))),span))));
+}
+__jakt_var_517 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::JaktTuple>(checked_values,span,type_id))); goto __jakt_label_459;
 
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-{
-JaktInternal::ArrayIterator<parser::ParsedRecord> _magic = ((((parsed_namespace).records)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedRecord> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedRecord record = (_magic_value.value());
-{
-types::ScopeId const record_scope_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::ScopeId, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((record).record_type);
+__jakt_label_459:; __jakt_var_517.release_value(); }));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedExpression>();NonnullRefPtr<typename parser::ParsedExpression> const& base = __jakt_match_value.base;
+NonnullRefPtr<typename parser::ParsedExpression> const& index = __jakt_match_value.index;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_518; {
+NonnullRefPtr<typename types::CheckedExpression> const checked_base = TRY((((*this).typecheck_expression_and_dereference_if_needed(base,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+NonnullRefPtr<typename types::CheckedExpression> const checked_index = TRY((((*this).typecheck_expression_and_dereference_if_needed(index,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+__jakt_var_518 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(((checked_base)->type())));
 switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_534; {
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
-if ((!(((struct_id).has_value())))){
-return JaktInternal::LoopContinue{};
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_519; {
+types::StructId const array_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+types::StructId const array_slice_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("ArraySlice"sv)))));
+types::StructId const dictionary_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
+NonnullRefPtr<typename types::CheckedExpression> result = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span)));
+if ((((id).equals(array_struct_id)) || ((id).equals(array_slice_struct_id)))){
+if ((((*this).is_integer(((checked_index)->type()))) || ((checked_index)->index() == 9 /* Range */))){
+types::TypeId const type_id = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *checked_index;
+switch(__jakt_match_variant.index()) {
+case 9: {
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_520; {
+types::StructId const array_slice_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("ArraySlice"sv)))));
+__jakt_var_520 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_slice_struct_id,args))))))); goto __jakt_label_462;
+
+}
+__jakt_label_462:; __jakt_var_520.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(((args)[static_cast<i64>(0LL)]));
+};/*case end*/
+}/*switch end*/
+}()
+));
+(result = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedExpression>(checked_base,checked_index,span,type_id))));
+}
+else {
+TRY((((*this).error(Jakt::DeprecatedString("Index must be an integer or a range"sv),span))));
+}
+
+}
+else if (((id).equals(dictionary_struct_id))){
+(result = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedDictionary>(checked_base,checked_index,span,((args)[static_cast<i64>(1LL)])))));
 }
-__jakt_var_534 = ((((*this).get_struct((struct_id.value())))).scope_id); goto __jakt_label_475;
+__jakt_var_519 = result; goto __jakt_label_461;
 
 }
-__jakt_label_475:; __jakt_var_534.release_value(); }));
+__jakt_label_461:; __jakt_var_519.release_value(); }));
 };/*case end*/
+default: {
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_521; {
+TRY((((*this).error(Jakt::DeprecatedString("Index used on value that cannot be indexed"sv),span))));
+__jakt_var_521 = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))); goto __jakt_label_463;
+
+}
+__jakt_label_463:; __jakt_var_521.release_value(); }));
+};/*case end*/
+}/*switch end*/
+}()
+)); goto __jakt_label_460;
+
+}
+__jakt_label_460:; __jakt_var_518.release_value(); }));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::IndexedTuple>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+size_t const& index = __jakt_match_value.index;
+bool const& is_optional = __jakt_match_value.is_optional;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_indexed_tuple(expr,index,scope_id,is_optional,safety_mode,span)))));
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename parser::ParsedExpression::Garbage>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span))));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::NamespacedVar>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<DeprecatedString> const& namespace_ = __jakt_match_value.namespace_;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_namespaced_var_or_simple_enum_constructor_call(name,namespace_,scope_id,safety_mode,type_hint,span)))));
+};/*case end*/
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Match>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+JaktInternal::DynamicArray<parser::ParsedMatchCase> const& cases = __jakt_match_value.cases;
+utility::Span const& marker_span = __jakt_match_value.marker_span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_match(expr,cases,marker_span,scope_id,safety_mode,type_hint)))));
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::EnumVariantArg>();NonnullRefPtr<typename parser::ParsedExpression> const& inner_expr = __jakt_match_value.expr;
+parser::EnumVariantPatternArgument const& arg = __jakt_match_value.arg;
+NonnullRefPtr<typename parser::ParsedType> const& enum_variant = __jakt_match_value.enum_variant;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_522; {
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(inner_expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+types::CheckedEnumVariantBinding checked_binding = types::CheckedEnumVariantBinding(Jakt::DeprecatedString(""sv),Jakt::DeprecatedString(""sv),types::unknown_type_id(),span);
+JaktInternal::Optional<types::CheckedEnumVariant> checked_enum_variant = JaktInternal::OptionalNone();
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *enum_variant;
+switch(__jakt_match_variant.index()) {
 case 1: {
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_535; {
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,((record).name)))));
-if ((!(((struct_id).has_value())))){
-return JaktInternal::LoopContinue{};
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& variant_name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(((checked_expr)->type())));
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+{
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+JaktInternal::Optional<types::CheckedEnumVariant> const variant = TRY((((*this).get_enum_variant(enum_,variant_name))));
+if (((variant).has_value())){
+(checked_enum_variant = variant);
+JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>> const checked_bindings = TRY((((*this).typecheck_enum_variant_bindings((variant.value()),(TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({arg})))),span))));
+if (((checked_bindings).has_value())){
+JaktInternal::DynamicArray<types::CheckedEnumVariantBinding> const bindings = (checked_bindings.value());
+(checked_binding = ((bindings)[static_cast<i64>(0LL)]));
+}
+}
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist"sv),variant_name))),span))));
 }
-__jakt_var_535 = ((((*this).get_struct((struct_id.value())))).scope_id); goto __jakt_label_476;
 
 }
-__jakt_label_476:; __jakt_var_535.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(({ Optional<types::ScopeId> __jakt_var_536; {
-JaktInternal::Optional<types::EnumId> const enum_id = TRY((((((*this).program))->find_enum_in_scope(scope_id,((record).name)))));
-if ((!(((enum_id).has_value())))){
-return JaktInternal::LoopContinue{};
-}
-__jakt_var_536 = ((((*this).get_enum((enum_id.value())))).scope_id); goto __jakt_label_477;
-
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),variant_name))),span))));
 }
-__jakt_label_477:; __jakt_var_536.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-));
-{
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((record).methods)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::ParsedMethod method = (_magic_value.value());
-{
-if (((!(((((record).generic_parameters)).is_empty()))) || (!(((((((method).parsed_function)).generic_parameters)).is_empty()))))){
-NonnullRefPtr<types::CheckedFunction> func = ((*this).get_function((TRY((((*this).find_function_matching_signature_in_scope(record_scope_id,((method).parsed_function))))).value())));
-types::ScopeId const method_scope_id = ((func)->function_scope_id);
-types::ScopeId const check_scope = TRY((((*this).create_scope(method_scope_id,((func)->can_throw),TRY((__jakt_format(Jakt::DeprecatedString("method-checking({}::{})"sv),((record).name),((func)->name)))),true))));
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((func)->params)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedParameter param = (_magic_value.value());
+))), JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& variant_name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *((*this).get_type(((checked_expr)->type())));
+switch(__jakt_match_variant.index()) {
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
 {
-TRY((((*this).add_var_to_scope(check_scope,((((param).variable))->name),TRY((((module)->add_variable(((param).variable))))),((((param).variable))->definition_span)))));
-}
-
-}
-}
-
-bool const old_ignore_errors = ((*this).ignore_errors);
-(((*this).ignore_errors) = true);
-types::CheckedBlock const block = TRY((((*this).typecheck_block(((((method).parsed_function)).block),check_scope, types::SafetyMode { typename types::SafetyMode::Safe() } ,JaktInternal::OptionalNone()))));
-(((*this).ignore_errors) = old_ignore_errors);
-(((*this).had_an_error) = false);
-types::TypeId const function_return_type_id = ((func)->return_type_id);
-types::TypeId return_type_id = types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } );
-if (((function_return_type_id).equals(types::unknown_type_id()))){
-if ((!(((((block).statements)).is_empty())))){
-if ((((((((block).statements)).last()).value()))->index() == 8 /* Return */)){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const val = (((((((block).statements)).last()).value()))->get<types::CheckedStatement::Return>()).val;
-if (((val).has_value())){
-(return_type_id = TRY((((*this).resolve_type_var((((val.value()))->type()),method_scope_id)))));
-}
-}
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+JaktInternal::Optional<types::CheckedEnumVariant> const variant = TRY((((*this).get_enum_variant(enum_,variant_name))));
+if (((variant).has_value())){
+(checked_enum_variant = variant);
+JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>> const checked_bindings = TRY((((*this).typecheck_enum_variant_bindings((variant.value()),(TRY((DynamicArray<parser::EnumVariantPatternArgument>::create_with({arg})))),span))));
+if (((checked_bindings).has_value())){
+JaktInternal::DynamicArray<types::CheckedEnumVariantBinding> const bindings = (checked_bindings.value());
+(checked_binding = ((bindings)[static_cast<i64>(0LL)]));
 }
 }
 else {
-(return_type_id = TRY((((*this).resolve_type_var(function_return_type_id,scope_id)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant {} does not exist"sv),variant_name))),span))));
 }
 
-(((func)->block) = block);
-(((func)->return_type_id) = return_type_id);
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type or invalid type name: {}"sv),variant_name))),span))));
 }
-
-}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+))), JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
 }
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+NonnullRefPtr<typename types::CheckedExpression> output = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Garbage>(span)));
+if (((checked_enum_variant).has_value())){
+(output = TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::EnumVariantArg>(checked_expr,checked_binding,(checked_enum_variant.value()),span))));
 }
+__jakt_var_522 = output; goto __jakt_label_464;
 
 }
+__jakt_label_464:; __jakt_var_522.release_value(); }));
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const& values = __jakt_match_value.values;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_dictionary(values,span,scope_id,safety_mode,type_hint)))));
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Set>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const& values = __jakt_match_value.values;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_set(values,span,scope_id,safety_mode,type_hint)))));
+};/*case end*/
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Function>();JaktInternal::DynamicArray<parser::ParsedCapture> const& captures = __jakt_match_value.captures;
+JaktInternal::DynamicArray<parser::ParsedParameter> const& params = __jakt_match_value.params;
+bool const& can_throw = __jakt_match_value.can_throw;
+bool const& is_fat_arrow = __jakt_match_value.is_fat_arrow;
+NonnullRefPtr<typename parser::ParsedType> const& return_type = __jakt_match_value.return_type;
+parser::ParsedBlock const& block = __jakt_match_value.block;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_lambda(captures,params,can_throw,is_fat_arrow,return_type,block,span,scope_id,safety_mode)))));
+};/*case end*/
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::Try>();NonnullRefPtr<typename parser::ParsedExpression> const& expr = __jakt_match_value.expr;
+JaktInternal::Optional<parser::ParsedBlock> const& catch_block = __jakt_match_value.catch_block;
+JaktInternal::Optional<DeprecatedString> const& catch_name = __jakt_match_value.catch_name;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_try(expr,catch_block,catch_name,scope_id,safety_mode,span,type_hint)))));
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedExpression::TryBlock>();NonnullRefPtr<typename parser::ParsedStatement> const& stmt = __jakt_match_value.stmt;
+parser::ParsedBlock const& catch_block = __jakt_match_value.catch_block;
+DeprecatedString const& error_name = __jakt_match_value.error_name;
+utility::Span const& error_span = __jakt_match_value.error_span;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(TRY((((*this).typecheck_try_block(stmt,error_name,error_span,catch_block,scope_id,safety_mode,span)))));
+};/*case end*/
+case 13: {
+{
+TRY((((((*this).compiler))->panic(Jakt::DeprecatedString("idk how to handle this thing"sv)))));
 }
-
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-return {};
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_enum_constructor(parser::ParsedRecord const parsed_record,types::EnumId const enum_id,types::ScopeId const parent_scope_id) {
-{
-u64 next_constant_value = static_cast<u64>(0ULL);
-JaktInternal::Set<DeprecatedString> seen_names = (TRY((Set<DeprecatedString>::create_with_values({}))));
-types::CheckedEnum enum_ = ((*this).get_enum(enum_id));
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = ((enum_).type_id));
-ScopeGuard __jakt_var_537([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
-JaktInternal::Set<DeprecatedString> common_seen_fields = (TRY((Set<DeprecatedString>::create_with_values({}))));
-JaktInternal::DynamicArray<types::VarId> common_fields = (TRY((DynamicArray<types::VarId>::create_with({}))));
-JaktInternal::DynamicArray<types::CheckedParameter> common_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_indexed_struct(NonnullRefPtr<typename parser::ParsedExpression> const expr,DeprecatedString const field_name,types::ScopeId const scope_id,bool const is_optional,types::SafetyMode const safety_mode,utility::Span const span) {
 {
-JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::CheckedField field = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression_and_dereference_if_needed(expr,scope_id,safety_mode,JaktInternal::OptionalNone(),span))));
+types::TypeId const checked_expr_type_id = ((checked_expr)->type());
+NonnullRefPtr<typename types::Type> const checked_expr_type = ((*this).get_type(checked_expr_type_id));
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *checked_expr_type;
+switch(__jakt_match_variant.index()) {
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
 {
-NonnullRefPtr<types::CheckedVariable> const variable = ((*this).get_variable(((field).variable_id)));
-TRY((((common_params).push(types::CheckedParameter(true,variable,((field).default_value))))));
-TRY((((common_seen_fields).add(((variable)->name)))));
-TRY((((common_fields).push(((field).variable_id)))));
-}
-
+types::TypeId type_id = checked_expr_type_id;
+if (is_optional){
+if ((!(((id).equals(optional_struct_id))))){
+TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is only allowed on optional types"sv),span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,types::unknown_type_id()))));
 }
+(type_id = ((args)[static_cast<i64>(0LL)]));
 }
-
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<void>>{
-auto&& __jakt_match_variant = ((parsed_record).record_type);
+NonnullRefPtr<typename types::Type> const type = ((*this).get_type(type_id));
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+ScopeGuard __jakt_var_523([&] {
+((((*this).generic_inferences)).restore(checkpoint));
+});
+TRY((((*this).map_generic_arguments(type_id,args))));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<NonnullRefPtr<typename types::CheckedExpression>>>{
+auto&& __jakt_match_variant = *type;
 switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::ValueEnum>();NonnullRefPtr<typename parser::ParsedType> const& underlying_type = __jakt_match_value.underlying_type;
-JaktInternal::DynamicArray<parser::ValueEnumVariant> const& variants = __jakt_match_value.variants;
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
 {
-types::TypeId const underlying_type_id = TRY((((*this).typecheck_typename(underlying_type,parent_scope_id,JaktInternal::OptionalNone()))));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::CheckedStruct const structure = ((*this).get_struct(struct_id));
 {
-JaktInternal::ArrayIterator<parser::ValueEnumVariant> _magic = ((variants).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ValueEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::ValueEnumVariant variant = (_magic_value.value());
-{
-if (((seen_names).contains(((variant).name)))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant '{}' is defined more than once"sv),((variant).name)))),((variant).span)))));
-}
-else {
-TRY((((seen_names).add(((variant).name)))));
-NonnullRefPtr<typename types::CheckedExpression> const expr = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::CheckedExpression>,ErrorOr<void>>{
-auto __jakt_enum_value = (((((variant).value)).has_value()));
-if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::CheckedExpression>> __jakt_var_538; {
-NonnullRefPtr<typename types::CheckedExpression> const value_expression = TRY((((*this).cast_to_underlying((((variant).value).value()),parent_scope_id,underlying_type))));
-JaktInternal::Optional<types::NumberConstant> const number_constant = ((value_expression)->to_number_constant(((*this).program)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<void>>{
-auto __jakt_enum_value = (((number_constant).has_value()));
-if (__jakt_enum_value == true) {
-{
-(next_constant_value = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP_NESTED_MATCH(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, ErrorOr<void>>{
-auto&& __jakt_match_variant = (number_constant.value());
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Signed>();
-i64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<u64>(((JaktInternal::checked_add<i64>(val,static_cast<i64>(1LL)))))));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Unsigned>();
-u64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((JaktInternal::checked_add<u64>(val,static_cast<u64>(1ULL))));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Floating>();
-f64 const& val = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(({ Optional<u64> __jakt_var_539; {
-utility::todo(Jakt::DeprecatedString("Implement floats"sv));
-__jakt_var_539 = static_cast<u64>(0ULL); goto __jakt_label_479;
-
-}
-__jakt_label_479:; __jakt_var_539.release_value(); }));
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-return JaktInternal::ExplicitValue<void>();
+break;
 }
-else {
+types::CheckedField field = (_magic_value.value());
 {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant '{}' in enum '{}' has a non-constant value: {}"sv),((variant).name),((enum_).name),value_expression))),((variant).span)))));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-__jakt_var_538 = value_expression; goto __jakt_label_478;
-
-}
-__jakt_label_478:; __jakt_var_538.release_value(); }));
-}
-else {
-return JaktInternal::ExplicitValue(TRY((((*this).cast_to_underlying(TRY((parser::ParsedExpression::template __jakt_create<typename parser::ParsedExpression::NumericConstant>( parser::NumericConstant { typename parser::NumericConstant::U64(((next_constant_value++))) } ,((variant).span)))),parent_scope_id,underlying_type)))));
+NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
+if ((((member)->name) == field_name)){
+types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
+if (is_optional){
+(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
 }
-}()))
-;
-TRY((((((enum_).variants)).push( types::CheckedEnumVariant { typename types::CheckedEnumVariant::WithValue(enum_id,((variant).name),expr,((variant).span)) } ))));
-types::VarId const var_id = TRY((((module)->add_variable(TRY((types::CheckedVariable::__jakt_create(((variant).name),((enum_).type_id),false,((variant).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())))))));
-TRY((((*this).add_var_to_scope(((enum_).scope_id),((variant).name),var_id,((variant).span)))));
+TRY((((*this).check_member_access(scope_id,((structure).scope_id),member,span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,resolved_type_id))));
 }
-
 }
 
 }
 }
 
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field_name))),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<parser::RecordType::SumEnum>();bool const& is_boxed = __jakt_match_value.is_boxed;
-JaktInternal::DynamicArray<parser::SumEnumVariant> const& variants = __jakt_match_value.variants;
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
 {
-NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::CheckedStruct const structure = ((*this).get_struct(struct_id));
 {
-JaktInternal::ArrayIterator<parser::SumEnumVariant> _magic = ((variants).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((structure).fields)).iterator());
 for (;;){
-JaktInternal::Optional<parser::SumEnumVariant> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::SumEnumVariant variant = (_magic_value.value());
+types::CheckedField field = (_magic_value.value());
 {
-if (((seen_names).contains(((variant).name)))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant '{}' is defined more than once"sv),((variant).name)))),((variant).span)))));
-continue;
+NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
+if ((((member)->name) == field_name)){
+types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
+if (is_optional){
+(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
 }
-TRY((((seen_names).add(((variant).name)))));
-bool const is_structlike = ((((((variant).params)).has_value()) && ((((((variant).params).value())).size()) > static_cast<size_t>(0ULL))) && ((((((((variant).params).value()))[static_cast<i64>(0LL)])).name) != Jakt::DeprecatedString(""sv)));
-bool const is_typed = ((((((variant).params)).has_value()) && ((((((variant).params).value())).size()) == static_cast<size_t>(1ULL))) && ((((((((variant).params).value()))[static_cast<i64>(0LL)])).name) == Jakt::DeprecatedString(""sv)));
-if (is_structlike){
-JaktInternal::Set<DeprecatedString> seen_fields = (TRY((Set<DeprecatedString>::create_with_values({}))));
-{
-JaktInternal::SetIterator<DeprecatedString> _magic = ((common_seen_fields).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((*this).check_member_access(scope_id,((structure).scope_id),member,span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,resolved_type_id))));
 }
-DeprecatedString name = (_magic_value.value());
-{
-TRY((((seen_fields).add(name))));
 }
 
 }
 }
 
-JaktInternal::DynamicArray<types::CheckedParameter> params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field_name))),span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((common_params).iterator());
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+types::CheckedField field = (_magic_value.value());
 {
-TRY((((params).push(param))));
+NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
+if ((((member)->name) == field_name)){
+types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
+if (is_optional){
+(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
 }
-
+TRY((((*this).check_member_access(scope_id,((enum_).scope_id),member,span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedCommonEnumMember>(checked_expr,field_name,span,is_optional,resolved_type_id))));
 }
 }
 
-JaktInternal::DynamicArray<types::VarId> fields = (TRY((DynamicArray<types::VarId>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::VarId> _magic = ((common_fields).iterator());
-for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::VarId field = (_magic_value.value());
-{
-TRY((((fields).push(field))));
 }
 
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown common member of enum: {}.{}"sv),((enum_).name),field_name))),span))));
 }
-}
-
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<parser::ParsedVarDecl> _magic = (((((variant).params).value())).iterator());
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedVarDecl> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedVarDecl param = (_magic_value.value());
+types::CheckedField field = (_magic_value.value());
 {
-if (((seen_fields).contains(((param).name)))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant '{}' has a member named '{}' more than once"sv),((variant).name),((param).name)))),((param).span)))));
-continue;
+NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
+if ((((member)->name) == field_name)){
+types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
+if (is_optional){
+(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
 }
-TRY((((seen_fields).add(((param).name)))));
-types::TypeId const type_id = TRY((((*this).typecheck_typename(((param).parsed_type),((enum_).scope_id),((param).name)))));
-NonnullRefPtr<types::CheckedVariable> const checked_var = TRY((types::CheckedVariable::__jakt_create(((param).name),type_id,((param).is_mutable),((param).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
-TRY((((params).push(types::CheckedParameter(true,checked_var,JaktInternal::OptionalNone())))));
-if ((((*this).dump_type_hints) && ((((param).parsed_type))->index() == 13 /* Empty */))){
-TRY((((*this).dump_type_hint(type_id,((param).span)))));
+TRY((((*this).check_member_access(scope_id,((enum_).scope_id),member,span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedCommonEnumMember>(checked_expr,field_name,span,is_optional,resolved_type_id))));
 }
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-types::VarId const var_id = TRY((((module)->add_variable(checked_var))));
-TRY((((fields).push(var_id))));
 }
 
 }
 }
 
-TRY((((((enum_).variants)).push( types::CheckedEnumVariant { typename types::CheckedEnumVariant::StructLike(enum_id,((variant).name),fields,((variant).span)) } ))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_enum_variant_constructor = TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),((variant).name)))));
-if ((!(((maybe_enum_variant_constructor).has_value())))){
-bool const can_function_throw = is_boxed;
-types::ScopeId const function_scope_id = TRY((((*this).create_scope(parent_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor({}::{})"sv),((enum_).name),((variant).name)))),true))));
-types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor-block({}::{})"sv),((enum_).name),((variant).name)))),true))));
-NonnullRefPtr<types::CheckedFunction> const checked_function = TRY((types::CheckedFunction::__jakt_create(((variant).name),((variant).span), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id))))))),JaktInternal::OptionalNone(),params,TRY((types::FunctionGenerics::__jakt_create(function_scope_id,params,(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,types::TypeId::none(),false),can_function_throw, parser::FunctionType { typename parser::FunctionType::ImplicitEnumConstructor() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,function_scope_id,JaktInternal::OptionalNone(),true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
-types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
-TRY((((*this).add_function_to_scope(((enum_).scope_id),((variant).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((variant).span)))));
-}
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown common member of enum: {}.{}"sv),((enum_).name),field_name))),span))));
 }
-else if (is_typed){
-JaktInternal::DynamicArray<types::CheckedParameter> params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((common_params).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+return (TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Member field access on value of non-struct type ‘{}’"sv),TRY((((*this).type_name(checked_expr_type_id,false))))))),span))))), JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
 }
-types::CheckedParameter param = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
 {
-TRY((((params).push(param))));
-}
-
+if (is_optional){
+TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on non-optional types"sv),span))));
 }
+types::CheckedStruct const structure = ((*this).get_struct(struct_id));
+JaktInternal::Optional<types::FieldRecord> const field_record = TRY((((*this).lookup_struct_field(struct_id,field_name))));
+if (((field_record).has_value())){
+NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable((((field_record.value())).field_id)));
+types::TypeId const resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
+TRY((((*this).check_member_access(scope_id,((((*this).get_struct((((field_record.value())).struct_id)))).scope_id),member,span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,resolved_type_id))));
 }
-
-parser::ParsedVarDecl const param = (((((variant).params).value()))[static_cast<i64>(0LL)]);
-types::TypeId const type_id = TRY((((*this).typecheck_typename(((param).parsed_type),((enum_).scope_id),((param).name)))));
-TRY((((((enum_).variants)).push( types::CheckedEnumVariant { typename types::CheckedEnumVariant::Typed(enum_id,((variant).name),type_id,((variant).span)) } ))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_enum_variant_constructor = TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),((variant).name)))));
-if ((!(((maybe_enum_variant_constructor).has_value())))){
-bool const can_function_throw = is_boxed;
-types::ScopeId const function_scope_id = TRY((((*this).create_scope(parent_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor({}::{})"sv),((enum_).name),((variant).name)))),true))));
-types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor-block({}::{})"sv),((enum_).name),((variant).name)))),true))));
-NonnullRefPtr<types::CheckedVariable> const variable = TRY((types::CheckedVariable::__jakt_create(Jakt::DeprecatedString("value"sv),type_id,false,((param).span),JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
-TRY((((params).push(types::CheckedParameter(false,variable,JaktInternal::OptionalNone())))));
-NonnullRefPtr<types::CheckedFunction> const checked_function = TRY((types::CheckedFunction::__jakt_create(((variant).name),((variant).span), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id))))))),JaktInternal::OptionalNone(),params,TRY((types::FunctionGenerics::__jakt_create(function_scope_id,params,(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } ,types::TypeId::none(),false),can_function_throw, parser::FunctionType { typename parser::FunctionType::ImplicitEnumConstructor() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,function_scope_id,JaktInternal::OptionalNone(),true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
-types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
-TRY((((*this).add_function_to_scope(((enum_).scope_id),((variant).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((variant).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown member of struct: {}.{}"sv),((structure).name),field_name))),span))));
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+{
+if (is_optional){
+TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on non-optional types"sv),span))));
 }
-else {
-JaktInternal::DynamicArray<types::CheckedParameter> params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+ScopeGuard __jakt_var_524([&] {
+((((*this).generic_inferences)).restore(checkpoint));
+});
+TRY((((*this).map_generic_arguments(checked_expr_type_id,args))));
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
 {
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((common_params).iterator());
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedParameter param = (_magic_value.value());
+types::CheckedField field = (_magic_value.value());
 {
-TRY((((params).push(param))));
+NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
+if ((((member)->name) == field_name)){
+types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
+if (is_optional){
+(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
+}
+TRY((((*this).check_member_access(scope_id,((enum_).scope_id),member,span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedCommonEnumMember>(checked_expr,field_name,span,is_optional,resolved_type_id))));
+}
 }
 
 }
 }
 
-TRY((((((enum_).variants)).push( types::CheckedEnumVariant { typename types::CheckedEnumVariant::Untyped(enum_id,((variant).name),((variant).span)) } ))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_enum_variant_constructor = TRY((((*this).find_functions_with_name_in_scope(((enum_).scope_id),((variant).name)))));
-if ((!(((maybe_enum_variant_constructor).has_value())))){
-bool const can_function_throw = is_boxed;
-types::ScopeId const function_scope_id = TRY((((*this).create_scope(parent_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor({}::{})"sv),((enum_).name),((variant).name)))),true))));
-types::ScopeId const block_scope_id = TRY((((*this).create_scope(function_scope_id,can_function_throw,TRY((__jakt_format(Jakt::DeprecatedString("enum-variant-constructor-block({}::{})"sv),((enum_).name),((variant).name)))),true))));
-NonnullRefPtr<types::CheckedFunction> const checked_function = TRY((types::CheckedFunction::__jakt_create(((variant).name),((variant).span), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Enum>(enum_id))))))),JaktInternal::OptionalNone(),params,TRY((types::FunctionGenerics::__jakt_create(function_scope_id,params,(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),block_scope_id, types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } ,types::TypeId::none(),false),can_function_throw, parser::FunctionType { typename parser::FunctionType::ImplicitEnumConstructor() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,function_scope_id,JaktInternal::OptionalNone(),true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
-types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
-TRY((((*this).add_function_to_scope(((enum_).scope_id),((variant).name),(TRY((DynamicArray<types::FunctionId>::create_with({function_id})))),((variant).span)))));
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown common member of enum: {}.{}"sv),((enum_).name),field_name))),span))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+JaktInternal::DynamicArray<types::TypeId> const args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+{
+if (is_optional){
+TRY((((*this).error(Jakt::DeprecatedString("Optional chaining is not allowed on non-optional types"sv),span))));
+}
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+ScopeGuard __jakt_var_525([&] {
+((((*this).generic_inferences)).restore(checkpoint));
+});
+TRY((((*this).map_generic_arguments(checked_expr_type_id,args))));
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+{
+JaktInternal::ArrayIterator<types::CheckedField> _magic = ((((enum_).fields)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedField> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedField field = (_magic_value.value());
+{
+NonnullRefPtr<types::CheckedVariable> const member = ((*this).get_variable(((field).variable_id)));
+if ((((member)->name) == field_name)){
+types::TypeId resolved_type_id = TRY((((*this).resolve_type_var(((member)->type_id),scope_id))));
+if (is_optional){
+(resolved_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({resolved_type_id}))))))))))));
 }
+TRY((((*this).check_member_access(scope_id,((enum_).scope_id),member,span))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedCommonEnumMember>(checked_expr,field_name,span,is_optional,resolved_type_id))));
 }
-
 }
 
 }
 }
 
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("unknown common member of enum: {}.{}"sv),((enum_).name),field_name))),span))));
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-{
-}
-return JaktInternal::ExplicitValue<void>();
+return (TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Member field access on value of non-struct type ‘{}’"sv),TRY((((*this).type_name(checked_expr_type_id,false))))))),span))))), JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
 ));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::IndexedStruct>(checked_expr,field_name,span,is_optional,types::unknown_type_id()))));
 }
-return {};
 }
 
-ErrorOr<void> typechecker::Typechecker::typecheck_enum(parser::ParsedRecord const record,types::EnumId const enum_id,types::ScopeId const parent_scope_id) {
+ErrorOr<void> typechecker::Typechecker::typecheck_namespace_imports(parser::ParsedNamespace const parsed_namespace,types::ScopeId const scope_id) {
 {
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = ((((*this).get_enum(enum_id))).type_id));
-ScopeGuard __jakt_var_540([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
 {
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((record).methods)).iterator());
+JaktInternal::ArrayIterator<parser::ParsedModuleImport> _magic = ((((parsed_namespace).module_imports)).iterator());
 for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedModuleImport> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-parser::ParsedMethod method = (_magic_value.value());
+parser::ParsedModuleImport module_import = (_magic_value.value());
 {
-TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Enum(JaktInternal::OptionalNone(),enum_id) } ))));
-}
-
-}
+TRY((((*this).typecheck_module_import(module_import,scope_id))));
 }
 
 }
-return {};
 }
 
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>>> typechecker::Typechecker::typecheck_enum_variant_bindings(types::CheckedEnumVariant const variant,JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const bindings,utility::Span const span) {
-{
-if (((variant).index() == 1 /* Typed */)){
-types::TypeId const type_id = ((variant).get<types::CheckedEnumVariant::Typed>()).type_id;
-if ((((bindings).size()) != static_cast<size_t>(1ULL))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Enum variant ‘{}’ must have exactly one argument"sv),((variant).name())))),span))));
-return (JaktInternal::OptionalNone());
-}
-return ((TRY((DynamicArray<types::CheckedEnumVariantBinding>::create_with({types::CheckedEnumVariantBinding(JaktInternal::OptionalNone(),((((bindings)[static_cast<i64>(0LL)])).binding),type_id,span)})))));
-}
-if (((variant).index() == 3 /* StructLike */)){
-JaktInternal::DynamicArray<types::VarId> const fields = ((variant).get<types::CheckedEnumVariant::StructLike>()).fields;
-JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> checked_vars = (TRY((DynamicArray<NonnullRefPtr<types::CheckedVariable>>::create_with({}))));
-JaktInternal::DynamicArray<types::CheckedEnumVariantBinding> checked_enum_variant_bindings = (TRY((DynamicArray<types::CheckedEnumVariantBinding>::create_with({}))));
 {
-JaktInternal::ArrayIterator<types::VarId> _magic = ((fields).iterator());
+JaktInternal::ArrayIterator<parser::ParsedExternImport> _magic = ((((parsed_namespace).extern_imports)).iterator());
 for (;;){
-JaktInternal::Optional<types::VarId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedExternImport> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::VarId field = (_magic_value.value());
+parser::ParsedExternImport extern_import = (_magic_value.value());
 {
-TRY((((checked_vars).push(((*this).get_variable(field))))));
-}
-
-}
+TRY((((*this).typecheck_extern_import(extern_import,scope_id))));
 }
 
-{
-JaktInternal::ArrayIterator<parser::EnumVariantPatternArgument> _magic = ((bindings).iterator());
-for (;;){
-JaktInternal::Optional<parser::EnumVariantPatternArgument> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-parser::EnumVariantPatternArgument binding = (_magic_value.value());
-{
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<types::CheckedVariable>> _magic = ((checked_vars).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-NonnullRefPtr<types::CheckedVariable> var = (_magic_value.value());
-{
-DeprecatedString const binding_name = ((binding).name).value_or_lazy_evaluated([&] { return ((binding).binding); });
-types::TypeId const type_id = ((var)->type_id);
-if ((binding_name == ((var)->name))){
-TRY((((checked_enum_variant_bindings).push(types::CheckedEnumVariantBinding(((binding).name),((binding).binding),type_id,span)))));
-break;
 }
 }
 
 }
+return {};
 }
 
+ErrorOr<jakt__path::Path> typechecker::Typechecker::get_root_path() const {
+{
+JaktInternal::Optional<types::LoadedModule> const root_module = ((((*this).program))->get_loaded_module(((*this).root_module_name)));
+if (((root_module).has_value())){
+utility::FileId const file_id = (((root_module.value())).file_id);
+return ((TRY((((((*this).compiler))->get_file_path(file_id)))).value()));
 }
-
+return (TRY((jakt__path::Path::from_string(Jakt::DeprecatedString("."sv)))));
 }
 }
 
-if ((((checked_enum_variant_bindings).size()) > static_cast<size_t>(0ULL))){
-return (checked_enum_variant_bindings);
-}
+ErrorOr<JaktInternal::Optional<typechecker::TraitImplementationDescriptor>> typechecker::Typechecker::find_singular_trait_implementation(types::TypeId const type_id,DeprecatedString const trait_name,types::ScopeId const scope_id,utility::Span const span) {
+{
+JaktInternal::Optional<types::TraitId> const trait_id = TRY((((*this).find_trait_in_scope(scope_id,trait_name))));
+if ((!(((trait_id).has_value())))){
 return (JaktInternal::OptionalNone());
 }
-else {
+JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> const trait_impls = TRY((((*this).find_all_implementations_of_trait(type_id,(trait_id.value())))));
+if (((trait_impls).is_empty())){
 return (JaktInternal::OptionalNone());
 }
-
+if ((((trait_impls).size()) > static_cast<size_t>(1ULL))){
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("type ‘{}’ implements trait ‘{}’ more than once, but a singular implementation is allowed"sv),TRY((((*this).type_name(type_id,false)))),trait_name))),span))));
 }
+return (typechecker::TraitImplementationDescriptor((trait_id.value()),trait_name,((trait_impls)[static_cast<i64>(0LL)])));
 }
-
-ErrorOr<bool> typechecker::Typechecker::implements_trait(types::TypeId const type_id,types::TraitId const trait_id,JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const generic_arguments) {
-{
-Function<ErrorOr<bool>(JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>, types::TraitId, JaktInternal::DynamicArray<types::TypeId>, typechecker::Typechecker&)> const has_matching_trait = [type_id](JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> trait_implementations, types::TraitId trait_id, JaktInternal::DynamicArray<types::TypeId> passed_generic_arguments, typechecker::Typechecker& typechecker) -> ErrorOr<bool> {
-{
-bool const old_ignore_errors = ((((typechecker))).ignore_errors);
-(((((typechecker))).ignore_errors) = true);
-ScopeGuard __jakt_var_541([&] {
-{
-(((((typechecker))).ignore_errors) = old_ignore_errors);
-(((((typechecker))).had_an_error) = false);
 }
 
-});
-bool found = false;
-{
-JaktInternal::ArrayIterator<JaktInternal::DynamicArray<types::TypeId>> _magic = ((trait_implementations).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::DynamicArray<types::TypeId> implemented_generic_arguments = (_magic_value.value());
-{
-if ((((implemented_generic_arguments).size()) != ((passed_generic_arguments).size()))){
-continue;
-}
-bool ok = false;
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((implemented_generic_arguments).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typechecker::Typechecker::typecheck_try(NonnullRefPtr<typename parser::ParsedExpression> const expr,JaktInternal::Optional<parser::ParsedBlock> const catch_block,JaktInternal::Optional<DeprecatedString> const catch_name,types::ScopeId const scope_id,types::SafetyMode const safety_mode,utility::Span const span,JaktInternal::Optional<types::TypeId> const type_hint) {
 {
-(ok = TRY((((((typechecker))).check_types_for_compat(((implemented_generic_arguments)[i]),((passed_generic_arguments)[i]),((((((typechecker))).generic_inferences))),utility::Span(utility::FileId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL),static_cast<size_t>(0ULL)))))));
-if ((!(ok))){
-break;
-}
+types::ScopeId const try_scope_id = TRY((((*this).create_scope(scope_id,true,Jakt::DeprecatedString("try"sv),true))));
+NonnullRefPtr<typename types::CheckedExpression> const checked_expr = TRY((((*this).typecheck_expression(expr,try_scope_id,safety_mode,type_hint))));
+types::StructId const error_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+JaktInternal::Optional<types::CheckedBlock> checked_catch_block = JaktInternal::OptionalNone();
+types::TypeId const expression_type_id = ((checked_expr)->type());
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+NonnullRefPtr<typename types::Type> const optional_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({expression_type_id})))))));
+types::TypeId const optional_type_id = TRY((((*this).find_or_add_type_id(optional_type))));
+types::TypeId type_id = optional_type_id;
+if (((catch_block).has_value())){
+NonnullRefPtr<types::Scope> const parent_scope = TRY((((*this).get_scope(scope_id))));
+types::ScopeId const catch_scope_id = TRY((((*this).create_scope(scope_id,((parent_scope)->can_throw),Jakt::DeprecatedString("catch"sv),true))));
+if (((catch_name).has_value())){
+types::StructId const error_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Error"sv)))));
+NonnullRefPtr<types::CheckedVariable> const error_decl = TRY((types::CheckedVariable::__jakt_create((catch_name.value()),((((*this).get_struct(error_struct_id))).type_id),false,span,JaktInternal::OptionalNone(), types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,JaktInternal::OptionalNone())));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::VarId const error_id = TRY((((module)->add_variable(error_decl))));
+TRY((((*this).add_var_to_scope(catch_scope_id,(catch_name.value()),error_id,span))));
 }
-
+types::CheckedBlock const block = TRY((((*this).typecheck_block((catch_block.value()),catch_scope_id,safety_mode,JaktInternal::OptionalNone()))));
+if ((((((block).control_flow)).always_transfers_control()) || ((((block).yielded_type)).has_value()))){
+if ((!(((((block).yielded_type).value_or_lazy_evaluated([&] { return expression_type_id; })).equals(expression_type_id))))){
+TRY((((*this).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Expected a value of type ‘{}’, but got ‘{}’"sv),TRY((((*this).type_name(expression_type_id,false)))),TRY((((*this).type_name((((block).yielded_type).value()),false))))))),span,TRY((__jakt_format(Jakt::DeprecatedString("Expression 'catch' block must either yield the same type as the expression it is catching, or yield nothing"sv)))),span))));
 }
+else {
+(type_id = ((block).yielded_type).value_or_lazy_evaluated([&] { return expression_type_id; }));
 }
 
-if ((!(ok))){
-continue;
-}
-(found = true);
-break;
 }
-
+else {
+if ((!(((expression_type_id).equals(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } )))))){
+TRY((((*this).error(Jakt::DeprecatedString("In a try expression that returns a value, 'catch' block must either yield a value or transfer control flow"sv),span))));
 }
 }
 
-return (found);
-}
+(checked_catch_block = block);
 }
-;
-JaktInternal::DynamicArray<types::TypeId> const empty = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-return (TRY((has_matching_trait(TRY((((*this).find_all_implementations_of_trait(type_id,trait_id)))),trait_id,generic_arguments.value_or_lazy_evaluated([&] { return empty; }),((*this))))));
+return (TRY((types::CheckedExpression::template __jakt_create<typename types::CheckedExpression::Try>(checked_expr,checked_catch_block,catch_name,span,type_id,expression_type_id))));
 }
 }
 
-ErrorOr<JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>>> typechecker::Typechecker::find_var_in_scope(types::ScopeId const scope_id,DeprecatedString const var) const {
+ErrorOr<types::TypeId> typechecker::Typechecker::typecheck_typename(NonnullRefPtr<typename parser::ParsedType> const parsed_type,types::ScopeId const scope_id,JaktInternal::Optional<DeprecatedString> const name) {
 {
-return (TRY((((((*this).program))->find_var_in_scope(scope_id,var)))));
-}
-}
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<types::TypeId>>{
+auto&& __jakt_match_variant = *parsed_type;
+switch(__jakt_match_variant.index()) {
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Reference>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_526; {
+types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
+__jakt_var_526 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Reference>(inner_type_id))))))); goto __jakt_label_465;
 
-ErrorOr<void> typechecker::Typechecker::typecheck_struct(parser::ParsedRecord const record,types::StructId const struct_id,types::ScopeId const parent_scope_id) {
-{
-types::TypeId const struct_type_id = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
-(((*this).current_struct_type_id) = struct_type_id);
-JaktInternal::Optional<types::TypeId> const old_self_type_id = ((*this).self_type_id);
-(((*this).self_type_id) = struct_type_id);
-ScopeGuard __jakt_var_542([&] {
-(((*this).self_type_id) = old_self_type_id);
-});
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>>> all_virtuals = (TRY((Dictionary<DeprecatedString, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>>>::create_with_entries({}))));
-JaktInternal::Optional<types::StructId> super_struct_id = ((((*this).get_struct(struct_id))).super_struct_id);
-while (((super_struct_id).has_value())){
-types::CheckedStruct const super_struct = ((*this).get_struct((super_struct_id.value())));
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(((super_struct).scope_id)))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> ___overload_set__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt_____overload_set__ = ___overload_set__;
-DeprecatedString const _ = ((jakt_____overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt_____overload_set__).template get<1>());
+__jakt_label_465:; __jakt_var_526.release_value(); }));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::MutableReference>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_527; {
+types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
+__jakt_var_527 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::MutableReference>(inner_type_id))))))); goto __jakt_label_466;
 
+}
+__jakt_label_466:; __jakt_var_527.release_value(); }));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::NamespacedName>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<DeprecatedString> const& namespaces = __jakt_match_value.namespaces;
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& params = __jakt_match_value.params;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_528; {
+types::ScopeId current_namespace_scope_id = scope_id;
 {
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((namespaces).iterator());
 for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
-break;
-}
-types::FunctionId function_id = (_magic_value.value());
-{
-NonnullRefPtr<types::CheckedFunction> const function = ((*this).get_function(function_id));
-if (((function)->is_virtual)){
-if ((!(((all_virtuals).contains(((function)->name)))))){
-TRY(all_virtuals.set(((function)->name), (TRY((DynamicArray<NonnullRefPtr<types::CheckedFunction>>::create_with({function}))))));
-}
-else {
-TRY((((((all_virtuals)[((function)->name)])).push(function))));
-}
-
-}
+break;
 }
-
+DeprecatedString ns = (_magic_value.value());
+{
+JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const result = TRY((((*this).find_namespace_in_scope(current_namespace_scope_id,ns,false))));
+if (((result).has_value())){
+(current_namespace_scope_id = (((result.value())).template get<0>()));
 }
+else {
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown namespace: '{}'"sv),ns))),span))));
+return (types::unknown_type_id());
 }
 
 }
@@ -12805,388 +12811,405 @@ TRY((((((all_virtuals)[((function)->name)])).push(function))));
 }
 }
 
-(super_struct_id = ((super_struct).super_struct_id));
-}
-typechecker::TraitImplCheck checks = TRY((typechecker::TraitImplCheck::make()));
-{
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const trait_implementations = ((((*this).get_struct(struct_id))).trait_implementations);
-TRY((((checks).ensure_capacity(((trait_implementations).size())))));
+JaktInternal::DynamicArray<types::TypeId> generic_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((trait_implementations).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((params).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> trait_name__trait_id_and_generic_params__ = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedType> param = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt__trait_name__trait_id_and_generic_params__ = trait_name__trait_id_and_generic_params__;
-DeprecatedString const trait_name = ((jakt__trait_name__trait_id_and_generic_params__).template get<0>());
-JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_id_and_generic_params = ((jakt__trait_name__trait_id_and_generic_params__).template get<1>());
-
-TRY((((checks).register_trait(((trait_id_and_generic_params).template get<0>()),trait_name,((((((*this).program))->get_trait(((trait_id_and_generic_params).template get<0>()))))->methods)))));
+types::TypeId const checked_arg = TRY((((*this).typecheck_typename(param,scope_id,name))));
+TRY((((generic_args).push(checked_arg))));
 }
 
 }
 }
 
+JaktInternal::Optional<types::TypeId> type_id = JaktInternal::OptionalNone();
+if (((generic_args).is_empty())){
+NonnullRefPtr<typename parser::ParsedType> const synthetic_typename = TRY((parser::ParsedType::template __jakt_create<typename parser::ParsedType::Name>(name,span)));
+(type_id = TRY((((*this).typecheck_typename(synthetic_typename,current_namespace_scope_id,name)))));
 }
-
-{
-JaktInternal::ArrayIterator<parser::ParsedMethod> _magic = ((((record).methods)).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedMethod> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else {
+(type_id = TRY((((*this).typecheck_generic_resolved_type(name,generic_args,current_namespace_scope_id,span)))));
 }
-parser::ParsedMethod method = (_magic_value.value());
-{
-if (((method).is_override)){
-if ((!(((all_virtuals).contains(((((method).parsed_function)).name)))))){
-TRY((((*this).error(Jakt::DeprecatedString("Missing virtual for override"sv),((((method).parsed_function)).name_span)))));
+
+__jakt_var_528 = (type_id.value()); goto __jakt_label_467;
+
 }
+__jakt_label_467:; __jakt_var_528.release_value(); }));
+};/*case end*/
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Name>();DeprecatedString const& name = __jakt_match_value.name;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_529; {
+JaktInternal::Optional<JaktInternal::Tuple<types::TypeId,types::ScopeId>> const maybe_type_and_scope = TRY((((*this).find_type_scope(scope_id,name))));
+if (((maybe_type_and_scope).has_value())){
+if ((!((((((maybe_type_and_scope.value())).template get<1>())).equals(((*this).prelude_scope_id())))))){
+return ((((maybe_type_and_scope.value())).template get<0>()));
 }
-else if (((all_virtuals).contains(((((method).parsed_function)).name)))){
-TRY((((*this).error(Jakt::DeprecatedString("Missing override keyword on function that is virtual"sv),((((method).parsed_function)).name_span)))));
 }
-TRY((((*this).typecheck_method(((method).parsed_function), types::StructLikeId { typename types::StructLikeId::Struct(JaktInternal::OptionalNone(),struct_id) } ))));
+__jakt_var_529 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId,ErrorOr<types::TypeId>>{
+auto __jakt_enum_value = (name);
+if (__jakt_enum_value == Jakt::DeprecatedString("i8"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } ));
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("i16"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } ));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("i32"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } ));
 }
-
-{
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(true))));
-ScopeGuard __jakt_var_543([&] {
-{
-((((*this).generic_inferences)).restore(old_generic_inferences));
+else if (__jakt_enum_value == Jakt::DeprecatedString("i64"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } ));
 }
-
-});
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const trait_implementations = ((((*this).get_struct(struct_id))).trait_implementations);
-TRY((((checks).ensure_capacity(((trait_implementations).size())))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> _magic = ((trait_implementations).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else if (__jakt_enum_value == Jakt::DeprecatedString("u8"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } ));
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> trait_name__trait_id_and_generic_params__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> const jakt__trait_name__trait_id_and_generic_params__ = trait_name__trait_id_and_generic_params__;
-DeprecatedString const trait_name = ((jakt__trait_name__trait_id_and_generic_params__).template get<0>());
-JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_id_and_generic_params = ((jakt__trait_name__trait_id_and_generic_params__).template get<1>());
-
-JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>> const trait_id_generic_params_ = trait_id_and_generic_params;
-types::TraitId const trait_id = ((trait_id_generic_params_).template get<0>());
-JaktInternal::DynamicArray<types::TypeId> const generic_params = ((trait_id_generic_params_).template get<1>());
-
-NonnullRefPtr<types::CheckedTrait> const trait_ = ((*this).get_trait(trait_id));
-if ((((((trait_)->generic_parameters)).size()) != ((generic_params).size()))){
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Trait ‘{}’ expects {} generic parameters, but {} were given"sv),trait_name,((((trait_)->generic_parameters)).size()),((generic_params).size())))),((trait_)->name_span)))));
-continue;
+else if (__jakt_enum_value == Jakt::DeprecatedString("u16"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } ));
 }
-TRY((((*this).specialize_trait(trait_id,generic_params))));
+else if (__jakt_enum_value == Jakt::DeprecatedString("u32"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } ));
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("u64"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } ));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("f32"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::F32() } ));
 }
-
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(((((*this).get_struct(struct_id))).scope_id)))));
-{
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> _magic = ((((scope)->functions)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else if (__jakt_enum_value == Jakt::DeprecatedString("f64"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::F64() } ));
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> name__overload_set__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> const jakt__name__overload_set__ = name__overload_set__;
-DeprecatedString const name = ((jakt__name__overload_set__).template get<0>());
-JaktInternal::DynamicArray<types::FunctionId> const overload_set = ((jakt__name__overload_set__).template get<1>());
-
-{
-JaktInternal::ArrayIterator<types::FunctionId> _magic = ((overload_set).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+else if (__jakt_enum_value == Jakt::DeprecatedString("c_char"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::CChar() } ));
 }
-types::FunctionId function_id = (_magic_value.value());
-{
-TRY((((checks).register_method(struct_type_id,name,function_id,((*this))))));
+else if (__jakt_enum_value == Jakt::DeprecatedString("c_int"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::CInt() } ));
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("usize"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Usize() } ));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("String"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::JaktString() } ));
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("bool"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Bool() } ));
 }
-
+else if (__jakt_enum_value == Jakt::DeprecatedString("void"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Void() } ));
 }
+else if (__jakt_enum_value == Jakt::DeprecatedString("never"sv)) {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Never() } ));
 }
-
+else {
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_530; {
+if (((maybe_type_and_scope).has_value())){
+return ((((maybe_type_and_scope.value())).template get<0>()));
 }
+TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Unknown type ‘{}’"sv),name))),span))));
+__jakt_var_530 = types::unknown_type_id(); goto __jakt_label_469;
 
-TRY((((checks).throw_errors(((((*this).get_struct(struct_id))).name_span),((*this))))));
-(((*this).current_struct_type_id) = JaktInternal::OptionalNone());
 }
-return {};
+__jakt_label_469:; __jakt_var_530.release_value(); }));
 }
+}()))
+; goto __jakt_label_468;
 
-ErrorOr<void> typechecker::Typechecker::typecheck_struct_predecl_initial(parser::ParsedRecord const parsed_record,size_t const struct_index,size_t const module_struct_len,types::ScopeId const scope_id) {
-{
-types::ModuleId const module_id = ((*this).current_module_id);
-types::StructId const struct_id = types::StructId(((*this).current_module_id),(JaktInternal::checked_add<size_t>(struct_index,module_struct_len)));
-NonnullRefPtr<types::Module> module = ((*this).current_module());
-TRY((((((module)->types)).push(TRY((types::Type::template __jakt_create<typename types::Type::Struct>(struct_id)))))));
-types::TypeId const struct_type_id = types::TypeId(module_id,(JaktInternal::checked_sub<size_t>(((((((*this).current_module()))->types)).size()),static_cast<size_t>(1ULL))));
-TRY((((*this).add_type_to_scope(scope_id,((parsed_record).name),struct_type_id,((parsed_record).name_span)))));
-types::ScopeId const struct_scope_id = TRY((((*this).create_scope(scope_id,false,TRY((__jakt_format(Jakt::DeprecatedString("struct({})"sv),((parsed_record).name)))),false))));
-NonnullRefPtr<types::Scope> scope = TRY((((*this).get_scope(struct_scope_id))));
-(((scope)->namespace_name) = ((parsed_record).name));
-(((scope)->external_name) = ((parsed_record).external_name));
-TRY((((((module)->structures)).push(types::CheckedStruct(((parsed_record).name),((parsed_record).name_span),(TRY((DynamicArray<types::CheckedGenericParameter>::create_with({})))),(TRY((DynamicArray<types::CheckedField>::create_with({})))),struct_scope_id,((parsed_record).definition_linkage),(TRY((Dictionary<DeprecatedString, JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>::create_with_entries({})))),((parsed_record).record_type),struct_type_id,JaktInternal::OptionalNone(),((parsed_record).external_name))))));
-}
-return {};
 }
+__jakt_label_468:; __jakt_var_529.release_value(); }));
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_531; {
+__jakt_var_531 = types::unknown_type_id(); goto __jakt_label_470;
 
-ErrorOr<void> typechecker::Typechecker::fill_trait_requirements(JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> const names,JaktInternal::DynamicArray<types::TraitId>& trait_requirements,JaktInternal::DynamicArray<types::TypeId>& trait_implementations,types::ScopeId const scope_id) {
-{
-TRY((((((trait_requirements))).ensure_capacity(((names).size())))));
-{
-JaktInternal::ArrayIterator<parser::ParsedNameWithGenericParameters> _magic = ((names).iterator());
-for (;;){
-JaktInternal::Optional<parser::ParsedNameWithGenericParameters> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-parser::ParsedNameWithGenericParameters name = (_magic_value.value());
-{
-JaktInternal::Optional<types::TypeId> type_id = TRY((((*this).find_type_in_scope(scope_id,((name).name)))));
-if (((type_id).has_value())){
-if (((((*this).get_type((type_id.value()))))->index() == 26 /* Trait */)){
-types::TraitId const trait_id = ((((*this).get_type((type_id.value()))))->get<types::Type::Trait>()).value;
-if ((!(((((name).generic_parameters)).is_empty())))){
-JaktInternal::DynamicArray<types::TypeId> generic_arguments = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+__jakt_label_470:; __jakt_var_531.release_value(); }));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktTuple>();JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& types = __jakt_match_value.types;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_532; {
+JaktInternal::DynamicArray<types::TypeId> checked_types = (TRY((DynamicArray<types::TypeId>::create_with({}))));
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((((name).generic_parameters)).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((types).iterator());
 for (;;){
 JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-NonnullRefPtr<typename parser::ParsedType> argument = (_magic_value.value());
+NonnullRefPtr<typename parser::ParsedType> parsed_type = (_magic_value.value());
 {
-TRY((((generic_arguments).push(TRY((((*this).typecheck_typename(argument,scope_id,JaktInternal::OptionalNone()))))))));
+TRY((((checked_types).push(TRY((((*this).typecheck_typename(parsed_type,scope_id,name))))))));
 }
 
 }
 }
 
-NonnullRefPtr<typename types::Type> const final_type = TRY((types::Type::template __jakt_create<typename types::Type::GenericTraitInstance>(trait_id,generic_arguments)));
-(type_id = TRY((((*this).find_or_add_type_id(final_type)))));
+types::StructId const tuple_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Tuple"sv)))));
+__jakt_var_532 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(tuple_struct_id,checked_types))))))); goto __jakt_label_471;
+
 }
-TRY((((((trait_implementations))).push((type_id.value())))));
-TRY((((((trait_requirements))).push(trait_id))));
+__jakt_label_471:; __jakt_var_532.release_value(); }));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::JaktArray>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_533; {
+types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
+types::StructId const array_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Array"sv)))));
+__jakt_var_533 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(array_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id}))))))))))); goto __jakt_label_472;
+
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Requirement ‘{}’ is not a trait"sv),((name).name)))),((name).name_span)))));
-continue;
+__jakt_label_472:; __jakt_var_533.release_value(); }));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Dictionary>();NonnullRefPtr<typename parser::ParsedType> const& key = __jakt_match_value.key;
+NonnullRefPtr<typename parser::ParsedType> const& value = __jakt_match_value.value;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_534; {
+types::TypeId const key_type_id = TRY((((*this).typecheck_typename(key,scope_id,name))));
+types::TypeId const value_type_id = TRY((((*this).typecheck_typename(value,scope_id,name))));
+types::StructId const dict_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Dictionary"sv)))));
+__jakt_var_534 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(dict_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({key_type_id, value_type_id}))))))))))); goto __jakt_label_473;
+
 }
+__jakt_label_473:; __jakt_var_534.release_value(); }));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Set>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_535; {
+types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
+types::StructId const set_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Set"sv)))));
+__jakt_var_535 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(set_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id}))))))))))); goto __jakt_label_474;
 
 }
-else {
-TRY((((*this).error(TRY((__jakt_format(Jakt::DeprecatedString("Couldn't find trait ‘{}’"sv),((name).name)))),((name).name_span)))));
-continue;
+__jakt_label_474:; __jakt_var_535.release_value(); }));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Optional>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_536; {
+types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
+types::StructId const optional_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("Optional"sv)))));
+__jakt_var_536 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(optional_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id}))))))))))); goto __jakt_label_475;
+
 }
+__jakt_label_475:; __jakt_var_536.release_value(); }));
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::WeakPtr>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_537; {
+types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
+types::StructId const weakptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+__jakt_var_537 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(weakptr_struct_id,(TRY((DynamicArray<types::TypeId>::create_with({inner_type_id}))))))))))); goto __jakt_label_476;
 
 }
+__jakt_label_476:; __jakt_var_537.release_value(); }));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::RawPtr>();NonnullRefPtr<typename parser::ParsedType> const& inner = __jakt_match_value.inner;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_538; {
+types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner,scope_id,name))));
+__jakt_var_538 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::RawPtr>(inner_type_id))))))); goto __jakt_label_477;
 
 }
+__jakt_label_477:; __jakt_var_538.release_value(); }));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::GenericType>();DeprecatedString const& name = __jakt_match_value.name;
+JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const& generic_parameters = __jakt_match_value.generic_parameters;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_539; {
+JaktInternal::DynamicArray<types::TypeId> checked_inner_types = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename parser::ParsedType>> _magic = ((generic_parameters).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedType>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+NonnullRefPtr<typename parser::ParsedType> inner_type = (_magic_value.value());
+{
+types::TypeId const inner_type_id = TRY((((*this).typecheck_typename(inner_type,scope_id,name))));
+TRY((((checked_inner_types).push(inner_type_id))));
 }
 
 }
-return {};
 }
 
-ErrorOr<DeprecatedString> typechecker::TraitImplCheck::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("TraitImplCheck("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("missing_methods: {}, ", missing_methods));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("unmatched_signatures: {}, ", unmatched_signatures));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("private_matching_methods: {}, ", private_matching_methods));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("already_implemented_for: {}", already_implemented_for));
+__jakt_var_539 = TRY((((*this).typecheck_generic_resolved_type(name,checked_inner_types,scope_id,span)))); goto __jakt_label_478;
+
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<void> typechecker::TraitImplCheck::ensure_capacity(size_t const count) {
-{
-TRY((((((*this).missing_methods)).ensure_capacity(count))));
-TRY((((((*this).unmatched_signatures)).ensure_capacity(count))));
-TRY((((((*this).private_matching_methods)).ensure_capacity(count))));
-TRY((((((*this).already_implemented_for)).ensure_capacity(count))));
+__jakt_label_478:; __jakt_var_539.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<parser::ParsedType::Function>();JaktInternal::DynamicArray<parser::ParsedParameter> const& params = __jakt_match_value.params;
+bool const& can_throw = __jakt_match_value.can_throw;
+NonnullRefPtr<typename parser::ParsedType> const& return_type = __jakt_match_value.return_type;
+utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(({ Optional<types::TypeId> __jakt_var_540; {
+DeprecatedString const function_name = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString,ErrorOr<types::TypeId>>{
+auto __jakt_enum_value = (((name).has_value()));
+if (__jakt_enum_value == true) {
+return JaktInternal::ExplicitValue((name.value()));
 }
-return {};
+else {
+return JaktInternal::ExplicitValue(({ Optional<DeprecatedString> __jakt_var_541;
+auto __jakt_var_542 = [&]() -> ErrorOr<DeprecatedString> { return TRY((__jakt_format(Jakt::DeprecatedString("lambda{}"sv),((((*this).lambda_count)++))))); }();
+if (!__jakt_var_542.is_error()) __jakt_var_541 = __jakt_var_542.release_value();
+__jakt_var_541; }).value_or_lazy_evaluated([&] { return Jakt::DeprecatedString(""sv); }));
 }
-
-ErrorOr<typechecker::TraitImplCheck> typechecker::TraitImplCheck::make() {
+}()))
+;
+JaktInternal::DynamicArray<types::CheckedParameter> checked_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+bool first = true;
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const old_generic_inferences = TRY((((((*this).generic_inferences)).perform_checkpoint(false))));
+ScopeGuard __jakt_var_543([&] {
 {
-return (typechecker::TraitImplCheck((TRY((Dictionary<DeprecatedString, JaktInternal::Dictionary<DeprecatedString,types::FunctionId>>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, JaktInternal::Dictionary<DeprecatedString,utility::Span>>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, JaktInternal::Dictionary<DeprecatedString,utility::Span>>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, typechecker::AlreadyImplementedFor>::create_with_entries({}))))));
-}
+((((*this).generic_inferences)).restore(old_generic_inferences));
 }
 
-typechecker::TraitImplCheck::TraitImplCheck(JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> a_missing_methods, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> a_unmatched_signatures, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> a_private_matching_methods, JaktInternal::Dictionary<DeprecatedString,typechecker::AlreadyImplementedFor> a_already_implemented_for) :missing_methods(move(a_missing_methods)), unmatched_signatures(move(a_unmatched_signatures)), private_matching_methods(move(a_private_matching_methods)), already_implemented_for(move(a_already_implemented_for)){}
-
-ErrorOr<void> typechecker::TraitImplCheck::register_trait(types::TraitId const trait_id,DeprecatedString const trait_name,JaktInternal::Dictionary<DeprecatedString,types::FunctionId> const trait_methods) {
-{
-TRY(((*this).unmatched_signatures).set(trait_name, (TRY((Dictionary<DeprecatedString, utility::Span>::create_with_entries({}))))));
-TRY(((*this).private_matching_methods).set(trait_name, (TRY((Dictionary<DeprecatedString, utility::Span>::create_with_entries({}))))));
-JaktInternal::Dictionary<DeprecatedString,types::FunctionId> missing_methods = (TRY((Dictionary<DeprecatedString, types::FunctionId>::create_with_entries({}))));
-TRY((((missing_methods).ensure_capacity(((trait_methods).size())))));
+});
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((trait_methods).iterator());
+JaktInternal::ArrayIterator<parser::ParsedParameter> _magic = ((params).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<parser::ParsedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> method_name__method_id__ = (_magic_value.value());
+parser::ParsedParameter param = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__method_name__method_id__ = method_name__method_id__;
-DeprecatedString const method_name = ((jakt__method_name__method_id__).template get<0>());
-types::FunctionId const method_id = ((jakt__method_name__method_id__).template get<1>());
-
-TRY((((missing_methods).set(method_name,method_id))));
-}
-
-}
+TRY((((checked_params).push(TRY((((*this).typecheck_parameter(param,scope_id,first,JaktInternal::OptionalNone(),JaktInternal::OptionalNone()))))))));
+(first = false);
 }
 
-TRY((((((*this).missing_methods)).set(trait_name,missing_methods))));
 }
-return {};
 }
 
-ErrorOr<void> typechecker::TraitImplCheck::register_method(types::TypeId const self_type_id,DeprecatedString const method_name,types::FunctionId const method_id,typechecker::Typechecker& typechecker) {
-{
-NonnullRefPtr<types::CheckedFunction> const method = ((((typechecker))).get_function(method_id));
+NonnullRefPtr<types::CheckedFunction> const checked_function = TRY((types::CheckedFunction::__jakt_create(function_name,span, types::CheckedVisibility { typename types::CheckedVisibility::Public() } ,TRY((((*this).typecheck_typename(return_type,scope_id,JaktInternal::OptionalNone())))),((return_type)->span()),checked_params,TRY((types::FunctionGenerics::__jakt_create(scope_id,checked_params,(TRY((DynamicArray<types::FunctionGenericParameter>::create_with({})))),(TRY((DynamicArray<JaktInternal::DynamicArray<types::TypeId>>::create_with({}))))))),types::CheckedBlock((TRY((DynamicArray<NonnullRefPtr<typename types::CheckedStatement>>::create_with({})))),scope_id, types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ,JaktInternal::OptionalNone(),false),can_throw, parser::FunctionType { typename parser::FunctionType::Expression() } , parser::FunctionLinkage { typename parser::FunctionLinkage::Internal() } ,scope_id,JaktInternal::OptionalNone(),true,JaktInternal::OptionalNone(),false,false,false,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
+NonnullRefPtr<types::Module> module = ((*this).current_module());
+types::FunctionId const function_id = TRY((((module)->add_function(checked_function))));
+JaktInternal::DynamicArray<types::TypeId> param_type_ids = (TRY((DynamicArray<types::TypeId>::create_with({}))));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> _magic = ((((*this).missing_methods)).iterator());
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((checked_function)->params)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> trait_name__methods__ = (_magic_value.value());
+types::CheckedParameter param = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> const jakt__trait_name__methods__ = trait_name__methods__;
-DeprecatedString const trait_name = ((jakt__trait_name__methods__).template get<0>());
-JaktInternal::Dictionary<DeprecatedString,types::FunctionId> const methods = ((jakt__trait_name__methods__).template get<1>());
-
-JaktInternal::Optional<types::FunctionId> const trait_method_id = ((methods).get(method_name));
-if (((trait_method_id).has_value())){
-NonnullRefPtr<types::CheckedFunction> const trait_method = ((((typechecker))).get_function((trait_method_id.value())));
-if (TRY((((((typechecker))).signatures_match(self_type_id,trait_method,method))))){
-if (((((method)->visibility)).index() == 0 /* Public */)){
-((((((*this).missing_methods))[trait_name])).remove(method_name));
-TRY(((*this).already_implemented_for).set(method_name, typechecker::AlreadyImplementedFor(trait_name,((method)->name_span))));
-break;
-}
-else {
-TRY((((((((*this).private_matching_methods))[trait_name])).set(method_name,((method)->name_span)))));
-continue;
+TRY((((param_type_ids).push(((((param).variable))->type_id)))));
 }
 
 }
-else {
-TRY((((((((*this).unmatched_signatures))[trait_name])).set(method_name,((method)->name_span)))));
-continue;
 }
 
+__jakt_var_540 = TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Function>(param_type_ids,can_throw,((checked_function)->return_type_id),function_id))))))); goto __jakt_label_479;
+
 }
-else {
-continue;
+__jakt_label_479:; __jakt_var_540.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-
 }
 
+types::TypeId typechecker::Typechecker::infer_function_return_type(types::CheckedBlock const block) const {
+{
+if (((((block).statements)).is_empty())){
+return (types::void_type_id());
+}
+if ((((((((block).statements)).last()).value()))->index() == 8 /* Return */)){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const val = (((((((block).statements)).last()).value()))->get<types::CheckedStatement::Return>()).val;
+if (((val).has_value())){
+return ((((val.value()))->type()));
 }
 }
-
+return (types::void_type_id());
 }
-return {};
 }
 
-ErrorOr<void> typechecker::TraitImplCheck::throw_errors(utility::Span const record_decl_span,typechecker::Typechecker& typechecker) {
-{
+ErrorOr<bool> typechecker::Typechecker::scope_lifetime_subsumes(JaktInternal::Optional<types::ScopeId> const larger,JaktInternal::Optional<types::ScopeId> const smaller,JaktInternal::Set<DeprecatedString>& checked) const {
 {
-JaktInternal::DictionaryIterator<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> _magic = ((((*this).missing_methods)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if ((!(((larger).has_value())))){
+return (false);
 }
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> trait_name__missing_methods__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> const jakt__trait_name__missing_methods__ = trait_name__missing_methods__;
-DeprecatedString const trait_name = ((jakt__trait_name__missing_methods__).template get<0>());
-JaktInternal::Dictionary<DeprecatedString,types::FunctionId> const missing_methods = ((jakt__trait_name__missing_methods__).template get<1>());
-
-JaktInternal::Dictionary<DeprecatedString,utility::Span> const unmatched_signatures = ((((*this).unmatched_signatures))[trait_name]);
-JaktInternal::Dictionary<DeprecatedString,utility::Span> const private_matching_methods = ((((*this).private_matching_methods))[trait_name]);
+if ((!(((smaller).has_value())))){
+return (true);
+}
+types::ScopeId const larger_id = (larger.value());
+types::ScopeId const smaller_id = (smaller.value());
+if (((((checked))).contains(TRY((((larger_id).to_string())))))){
+return (false);
+}
+TRY((((((checked))).add(TRY((((larger_id).to_string())))))));
+JaktInternal::Optional<types::ScopeId> scope_id = static_cast<JaktInternal::Optional<types::ScopeId>>(larger_id);
+bool first = true;
+while (((scope_id).has_value())){
+if (((!(first)) && (((scope_id.value())).equals(smaller_id)))){
+return (true);
+}
+(first = false);
+NonnullRefPtr<types::Scope> const scope = TRY((((((*this).program))->get_scope((scope_id.value())))));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::FunctionId> _magic = ((missing_methods).iterator());
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::FunctionId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> method_name__trait_method_id__ = (_magic_value.value());
+types::ScopeId child_scope_id = (_magic_value.value());
 {
-JaktInternal::Tuple<DeprecatedString,types::FunctionId> const jakt__method_name__trait_method_id__ = method_name__trait_method_id__;
-DeprecatedString const method_name = ((jakt__method_name__trait_method_id__).template get<0>());
-types::FunctionId const trait_method_id = ((jakt__method_name__trait_method_id__).template get<1>());
-
-JaktInternal::Optional<typechecker::AlreadyImplementedFor> const already_implemented_for = ((((*this).already_implemented_for)).get(method_name));
-JaktInternal::Optional<utility::Span> const unmatched_signature = ((unmatched_signatures).get(method_name));
-JaktInternal::Optional<utility::Span> const private_matching_method = ((private_matching_methods).get(method_name));
-if (((already_implemented_for).has_value())){
-TRY((((((typechecker))).error(TRY((__jakt_format(Jakt::DeprecatedString("Cannot implement ‘{}’ for ‘{}’ because it's already implementing ‘{}’"sv),method_name,trait_name,(((already_implemented_for.value())).trait_name)))),(((already_implemented_for.value())).encounter_span)))));
-}
-else if (((private_matching_method).has_value())){
-utility::Span const span = (private_matching_method.value());
-TRY((((((typechecker))).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Implementation of ‘{}’ for trait ‘{}’ is valid but is not public"sv),method_name,trait_name))),span,Jakt::DeprecatedString("Consider adding ‘public’ to make the method accessible"sv),span))));
-}
-else {
-NonnullRefPtr<types::CheckedFunction> const func = ((((typechecker))).get_function(trait_method_id));
-if ((!(((((((func)->block)).statements)).is_empty())))){
-continue;
-}
-if (((unmatched_signature).has_value())){
-utility::Span const method_span = (unmatched_signature.value());
-TRY((((((typechecker))).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Missing implementation for method ‘{}’ of trait ‘{}’"sv),method_name,trait_name))),record_decl_span,Jakt::DeprecatedString("The method is declared here, but its signature doesn't match"sv),method_span))));
+if (TRY((((*this).scope_lifetime_subsumes(child_scope_id,smaller_id,checked))))){
+return (true);
 }
-else {
-utility::Span const trait_method_span = ((((((typechecker))).get_function(trait_method_id)))->name_span);
-TRY((((((typechecker))).error_with_hint(TRY((__jakt_format(Jakt::DeprecatedString("Missing implementation for method ‘{}’ of trait ‘{}’"sv),method_name,trait_name))),record_decl_span,Jakt::DeprecatedString("Consider implementing the method with the signature specified here"sv),trait_method_span))));
 }
 
 }
-
 }
 
+(scope_id = ((scope)->parent));
 }
+return (false);
 }
-
 }
 
+ErrorOr<bool> typechecker::Typechecker::scope_lifetime_subsumes(JaktInternal::Optional<types::ScopeId> const larger,JaktInternal::Optional<types::ScopeId> const smaller) const {
+{
+JaktInternal::Set<DeprecatedString> checked = (TRY((Set<DeprecatedString>::create_with_values({}))));
+return (TRY((((*this).scope_lifetime_subsumes(larger,smaller,((checked)))))));
 }
 }
 
+ErrorOr<DeprecatedString> typechecker::NumericOrStringValue::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* StringValue */: {
+TRY(builder.append("NumericOrStringValue::StringValue"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericOrStringValue::StringValue>();
+TRY(builder.appendff("(\"{}\")", that.value));
+break;}
+case 1 /* SignedNumericValue */: {
+TRY(builder.append("NumericOrStringValue::SignedNumericValue"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericOrStringValue::SignedNumericValue>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 2 /* UnsignedNumericValue */: {
+TRY(builder.append("NumericOrStringValue::UnsignedNumericValue"sv));
+[[maybe_unused]] auto const& that = this->template get<NumericOrStringValue::UnsignedNumericValue>();
+TRY(builder.appendff("({})", that.value));
+break;}
 }
-return {};
+return builder.to_string();
 }
-
 ErrorOr<DeprecatedString> typechecker::FunctionMatchResult::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
 switch (this->index()) {case 0 /* MatchSuccess */: {
@@ -13223,25 +13246,5 @@ break;}
 }
 return builder.to_string();
 }
-ErrorOr<DeprecatedString> typechecker::NumericOrStringValue::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* StringValue */: {
-TRY(builder.append("NumericOrStringValue::StringValue"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericOrStringValue::StringValue>();
-TRY(builder.appendff("(\"{}\")", that.value));
-break;}
-case 1 /* SignedNumericValue */: {
-TRY(builder.append("NumericOrStringValue::SignedNumericValue"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericOrStringValue::SignedNumericValue>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 2 /* UnsignedNumericValue */: {
-TRY(builder.append("NumericOrStringValue::UnsignedNumericValue"sv));
-[[maybe_unused]] auto const& that = this->template get<NumericOrStringValue::UnsignedNumericValue>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/typechecker.h b/bootstrap/stage0/typechecker.h
index ac373e5f9..b3c435aa8 100644
--- a/bootstrap/stage0/typechecker.h
+++ b/bootstrap/stage0/typechecker.h
@@ -11,6 +11,39 @@
 #include "interpreter.h"
 namespace Jakt {
 namespace typechecker {
+struct TraitImplementationDescriptor {
+  public:
+types::TraitId trait_id;DeprecatedString trait_name;JaktInternal::DynamicArray<types::TypeId> implemented_type_args;TraitImplementationDescriptor(types::TraitId a_trait_id, DeprecatedString a_trait_name, JaktInternal::DynamicArray<types::TypeId> a_implemented_type_args);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace FunctionMatchResult_Details {
+struct MatchSuccess {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> args;
+JaktInternal::Optional<types::TypeId> maybe_this_type_id;
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> used_generic_inferences;
+i64 specificity;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+MatchSuccess(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+args{ forward<_MemberT0>(member_0)},
+maybe_this_type_id{ forward<_MemberT1>(member_1)},
+used_generic_inferences{ forward<_MemberT2>(member_2)},
+specificity{ forward<_MemberT3>(member_3)}
+{}
+};
+struct MatchError {
+JaktInternal::DynamicArray<error::JaktError> errors;
+template<typename _MemberT0>
+MatchError(_MemberT0&& member_0):
+errors{ forward<_MemberT0>(member_0)}
+{}
+};
+}
+struct FunctionMatchResult : public Variant<FunctionMatchResult_Details::MatchSuccess, FunctionMatchResult_Details::MatchError> {
+using Variant<FunctionMatchResult_Details::MatchSuccess, FunctionMatchResult_Details::MatchError>::Variant;
+    using MatchSuccess = FunctionMatchResult_Details::MatchSuccess;
+    using MatchError = FunctionMatchResult_Details::MatchError;
+ErrorOr<DeprecatedString> debug_description() const;
+};
 namespace NumericOrStringValue_Details {
 struct StringValue{
 DeprecatedString value;
@@ -41,248 +74,215 @@ using Variant<NumericOrStringValue_Details::StringValue, NumericOrStringValue_De
     using UnsignedNumericValue = NumericOrStringValue_Details::UnsignedNumericValue;
 ErrorOr<DeprecatedString> debug_description() const;
 };
-struct TraitImplementationDescriptor {
+struct TraitImplCheck {
   public:
-types::TraitId trait_id;DeprecatedString trait_name;JaktInternal::DynamicArray<types::TypeId> implemented_type_args;TraitImplementationDescriptor(types::TraitId a_trait_id, DeprecatedString a_trait_name, JaktInternal::DynamicArray<types::TypeId> a_implemented_type_args);
+JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> missing_methods;JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> unmatched_signatures;JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> private_matching_methods;JaktInternal::Dictionary<DeprecatedString,typechecker::AlreadyImplementedFor> already_implemented_for;ErrorOr<void> throw_errors(utility::Span const record_decl_span, typechecker::Typechecker& typechecker);
+ErrorOr<void> ensure_capacity(size_t const count);
+ErrorOr<void> register_method(types::TypeId const self_type_id, DeprecatedString const method_name, types::FunctionId const method_id, typechecker::Typechecker& typechecker);
+static ErrorOr<typechecker::TraitImplCheck> make();
+TraitImplCheck(JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> a_missing_methods, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> a_unmatched_signatures, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> a_private_matching_methods, JaktInternal::Dictionary<DeprecatedString,typechecker::AlreadyImplementedFor> a_already_implemented_for);
 
+ErrorOr<void> register_trait(types::TraitId const trait_id, DeprecatedString const trait_name, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> const trait_methods);
 ErrorOr<DeprecatedString> debug_description() const;
 };struct Typechecker {
   public:
-NonnullRefPtr<compiler::Compiler> compiler;NonnullRefPtr<types::CheckedProgram> program;types::ModuleId current_module_id;JaktInternal::Optional<types::TypeId> current_struct_type_id;JaktInternal::Optional<types::FunctionId> current_function_id;bool inside_defer;size_t checkidx;bool ignore_errors;bool dump_type_hints;bool dump_try_hints;u64 lambda_count;types::GenericInferences generic_inferences;JaktInternal::Optional<types::TypeId> self_type_id;DeprecatedString root_module_name;bool in_comptime_function_call;bool had_an_error;ErrorOr<void> typecheck_namespace_predecl(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
-bool is_struct(types::TypeId const type_id) const;
-ErrorOr<void> dump_try_hint(utility::Span const span) const;
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_call(parser::ParsedCall const call, types::ScopeId const caller_scope_id, utility::Span const span, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const this_expr, JaktInternal::Optional<types::StructLikeId> const parent_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> type_hint, bool const must_be_enum_constructor);
-ErrorOr<JaktInternal::Optional<types::ScopeId>> scope_lifetime_union(JaktInternal::Optional<types::ScopeId> const first, JaktInternal::Optional<types::ScopeId> const second) const;
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_namespaced_var_or_simple_enum_constructor_call(DeprecatedString const name, JaktInternal::DynamicArray<DeprecatedString> const namespace_, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint, utility::Span const span);
-NonnullRefPtr<types::Module> current_module() const;
-ErrorOr<NonnullRefPtr<typename types::Type>> unwrap_type_from_optional_if_needed(NonnullRefPtr<typename types::Type> const type) const;
+NonnullRefPtr<compiler::Compiler> compiler;NonnullRefPtr<types::CheckedProgram> program;types::ModuleId current_module_id;JaktInternal::Optional<types::TypeId> current_struct_type_id;JaktInternal::Optional<types::FunctionId> current_function_id;bool inside_defer;size_t checkidx;bool ignore_errors;bool dump_type_hints;bool dump_try_hints;u64 lambda_count;types::GenericInferences generic_inferences;JaktInternal::Optional<types::TypeId> self_type_id;DeprecatedString root_module_name;bool in_comptime_function_call;bool had_an_error;ErrorOr<void> typecheck_struct_predecl_initial(parser::ParsedRecord const parsed_record, size_t const struct_index, size_t const module_struct_len, types::ScopeId const scope_id);
+ErrorOr<JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>>> typecheck_match_body(parser::ParsedMatchBody const body, types::ScopeId const scope_id, types::SafetyMode const safety_mode, types::GenericInferences& generic_inferences, JaktInternal::Optional<types::TypeId> const final_result_type, utility::Span const span);
+ErrorOr<DeprecatedString> type_name(types::TypeId const type_id, bool const debug_mode) const;
+ErrorOr<types::ScopeId> create_scope(JaktInternal::Optional<types::ScopeId> const parent_scope_id, bool const can_throw, DeprecatedString const debug_name, bool const for_block);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_return(JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const expr, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode);
+NonnullRefPtr<types::CheckedTrait> get_trait(types::TraitId const id) const;
+ErrorOr<void> typecheck_namespace_function_predecl(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_set(JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const values, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>>> find_functions_with_name_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
+bool is_class(types::TypeId const type_id) const;
+ErrorOr<types::CheckedVisibility> typecheck_visibility(parser::Visibility const visibility, types::ScopeId const scope_id);
+ErrorOr<JaktInternal::Optional<types::Value>> find_comptime_binding_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_try_block(NonnullRefPtr<typename parser::ParsedStatement> const stmt, DeprecatedString const error_name, utility::Span const error_span, parser::ParsedBlock const catch_block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<void> typecheck_enum_constructor(parser::ParsedRecord const parsed_record, types::EnumId const enum_id, types::ScopeId const parent_scope_id);
 ErrorOr<void> typecheck_trait(parser::ParsedTrait const parsed_trait, types::TraitId const trait_id, types::ScopeId const scope_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_indexed_tuple(NonnullRefPtr<typename parser::ParsedExpression> const expr, size_t const index, types::ScopeId const scope_id, bool const is_optional, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_match(NonnullRefPtr<typename parser::ParsedExpression> const expr, JaktInternal::DynamicArray<parser::ParsedMatchCase> const cases, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
-ErrorOr<void> typecheck_module(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
-ErrorOr<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> find_all_implementations_of_trait(types::TypeId const type_id, types::TraitId const trait_id);
-ErrorOr<types::TypeId> substitute_typevars_in_type(types::TypeId const type_id, types::GenericInferences const generic_inferences);
+ErrorOr<typechecker::FunctionMatchResult> match_function_and_resolve_args(parser::ParsedCall const call, types::ScopeId const caller_scope_id, types::FunctionId const candidate, types::SafetyMode const safety_mode, utility::Span const span, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const this_expr);
+ErrorOr<types::TypeId> unify_with_type(types::TypeId const found_type, JaktInternal::Optional<types::TypeId> const expected_type, utility::Span const span);
+bool is_numeric(types::TypeId const type_id) const;
 ErrorOr<types::StructId> find_struct_in_prelude(DeprecatedString const name) const;
-ErrorOr<void> typecheck_module_import(parser::ParsedModuleImport const import_, types::ScopeId const scope_id);
-ErrorOr<types::TypeId> typecheck_binary_operation(NonnullRefPtr<typename types::CheckedExpression> const checked_lhs, parser::BinaryOperator const op, NonnullRefPtr<typename types::CheckedExpression> const checked_rhs, types::ScopeId const scope_id, utility::Span const span);
-ErrorOr<JaktInternal::Optional<types::StructId>> find_struct_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+types::CheckedStruct get_struct(types::StructId const id) const;
+types::CheckedEnum get_enum(types::EnumId const id) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> dereference_if_needed(NonnullRefPtr<typename types::CheckedExpression> const checked_expr, utility::Span const span);
+ErrorOr<void> dump_type_hint(types::TypeId const type_id, utility::Span const span) const;
+ErrorOr<void> fill_trait_implementation_list(JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> const parsed_impl_list, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>& trait_implementations, types::ScopeId const scope_id, JaktInternal::Optional<types::ScopeId> const trait_name_scope_id_override);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_unary_negate(NonnullRefPtr<typename types::CheckedExpression> const expr, utility::Span const span, types::TypeId const type_id);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_statement(NonnullRefPtr<typename parser::ParsedStatement> const statement, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
 ErrorOr<void> typecheck_function(parser::ParsedFunction const parsed_function, types::ScopeId const parent_scope_id);
+ErrorOr<void> typecheck_namespace_declarations(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
+ErrorOr<void> typecheck_struct_constructor(parser::ParsedRecord const parsed_record, types::StructId const struct_id, types::ScopeId const scope_id);
+ErrorOr<types::TypeId> resolve_type_var(types::TypeId const type_var_type_id, types::ScopeId const scope_id) const;
 ErrorOr<void> check_type_argument_requirements(types::TypeId const generic_argument, JaktInternal::DynamicArray<types::TraitId> const constraints, utility::Span const arg_span);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_inline_cpp(parser::ParsedBlock const block, utility::Span const span, types::SafetyMode const safety_mode);
-bool is_class(types::TypeId const type_id) const;
-ErrorOr<void> typecheck_struct_fields(parser::ParsedRecord const record, types::StructId const struct_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_block_statement(parser::ParsedBlock const parsed_block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>>> get_type_ids_from_type_hint_if_struct_ids_match(JaktInternal::Optional<types::TypeId> const type_hint, types::StructId const expected_struct_id) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_generic_arguments_method_call(NonnullRefPtr<typename types::CheckedExpression> const checked_expr, parser::ParsedCall const call, types::ScopeId const scope_id, utility::Span const span, bool const is_optional, types::SafetyMode const safety_mode);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_loop(parser::ParsedBlock const parsed_block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<NonnullRefPtr<types::Scope>> get_scope(types::ScopeId const id) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_indexed_tuple(NonnullRefPtr<typename parser::ParsedExpression> const expr, size_t const index, types::ScopeId const scope_id, bool const is_optional, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_while(NonnullRefPtr<typename parser::ParsedExpression> const condition, parser::ParsedBlock const block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<void> typecheck_alias(parser::ParsedAlias const alias, types::ScopeId const scope_id, typechecker::ImportRestrictions const allow);
+ErrorOr<types::CheckedUnaryOperator> typecheck_is_enum_variant(NonnullRefPtr<typename types::CheckedExpression> const checked_expr, NonnullRefPtr<typename parser::ParsedType> const inner, JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const bindings, types::ScopeId const scope_id);
+ErrorOr<bool> add_var_to_scope(types::ScopeId const scope_id, DeprecatedString const name, types::VarId const var_id, utility::Span const span);
+ErrorOr<bool> add_comptime_binding_to_scope(types::ScopeId const scope_id, DeprecatedString const name, types::Value const value, utility::Span const span);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_match(NonnullRefPtr<typename parser::ParsedExpression> const expr, JaktInternal::DynamicArray<parser::ParsedMatchCase> const cases, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
+ErrorOr<void> map_generic_arguments(types::TypeId const type_id, JaktInternal::DynamicArray<types::TypeId> const args);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_throw(NonnullRefPtr<typename parser::ParsedExpression> const expr, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<void> fill_trait_requirements(JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> const names, JaktInternal::DynamicArray<types::TraitId>& trait_requirements, JaktInternal::DynamicArray<types::TypeId>& trait_implementations, types::ScopeId const scope_id);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_dictionary(JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const values, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
+ErrorOr<types::CheckedBlock> typecheck_block(parser::ParsedBlock const parsed_block, types::ScopeId const parent_scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const yield_type_hint);
+ErrorOr<void> typecheck_namespace_default_fields(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
+ErrorOr<void> typecheck_jakt_main(parser::ParsedFunction const parsed_function, types::ScopeId const parent_scope_id);
+ErrorOr<types::TypeId> typecheck_binary_operation(NonnullRefPtr<typename types::CheckedExpression> const checked_lhs, parser::BinaryOperator const op, NonnullRefPtr<typename types::CheckedExpression> const checked_rhs, types::ScopeId const scope_id, utility::Span const span);
+ErrorOr<void> typecheck_enum_predecl_initial(parser::ParsedRecord const parsed_record, size_t const enum_index, size_t const module_enum_len, types::ScopeId const scope_id);
+ErrorOr<types::TypeId> typecheck_generic_resolved_type(DeprecatedString const name, JaktInternal::DynamicArray<types::TypeId> const checked_inner_types, types::ScopeId const scope_id, utility::Span const span);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_comptime_index(NonnullRefPtr<typename parser::ParsedExpression> const expr, NonnullRefPtr<typename parser::ParsedExpression> const index, types::ScopeId const scope_id, bool const is_optional, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<void> typecheck_namespace_fields(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
 Typechecker(NonnullRefPtr<compiler::Compiler> a_compiler, NonnullRefPtr<types::CheckedProgram> a_program, types::ModuleId a_current_module_id, JaktInternal::Optional<types::TypeId> a_current_struct_type_id, JaktInternal::Optional<types::FunctionId> a_current_function_id, bool a_inside_defer, size_t a_checkidx, bool a_ignore_errors, bool a_dump_type_hints, bool a_dump_try_hints, u64 a_lambda_count, types::GenericInferences a_generic_inferences, JaktInternal::Optional<types::TypeId> a_self_type_id, DeprecatedString a_root_module_name, bool a_in_comptime_function_call, bool a_had_an_error);
 
-bool is_subclass_of(types::TypeId const ancestor_type_id, types::TypeId const child_type_id) const;
-ErrorOr<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>>> expand_context_for_bindings(NonnullRefPtr<typename parser::ParsedExpression> const condition, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const acc, JaktInternal::Optional<parser::ParsedBlock> const then_block, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const else_statement, utility::Span const span);
-ErrorOr<JaktInternal::Optional<types::CheckedEnumVariant>> get_enum_variant(types::CheckedEnum const enum_, DeprecatedString const variant_name);
-ErrorOr<void> check_implicit_constructor_argument_access(types::ScopeId const caller_scope_id, parser::ParsedCall const call, types::CheckedStruct const struct_);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_array(types::ScopeId const scope_id, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const values, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const fill_size, utility::Span const span, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
-ErrorOr<NonnullRefPtr<types::Scope>> get_scope(types::ScopeId const id) const;
-ErrorOr<bool> check_types_for_compat(types::TypeId const lhs_type_id, types::TypeId const rhs_type_id, types::GenericInferences& generic_inferences, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_lambda(JaktInternal::DynamicArray<parser::ParsedCapture> const captures, JaktInternal::DynamicArray<parser::ParsedParameter> const params, bool const can_throw, bool const is_fat_arrow, NonnullRefPtr<typename parser::ParsedType> const return_type, parser::ParsedBlock const block, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode);
-types::CheckedStruct get_struct(types::StructId const id) const;
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_return(JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const expr, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode);
-ErrorOr<void> check_that_type_doesnt_contain_reference(types::TypeId const type_id, utility::Span const span);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> cast_to_underlying(NonnullRefPtr<typename parser::ParsedExpression> const expr, types::ScopeId const scope_id, NonnullRefPtr<typename parser::ParsedType> const parsed_type);
+ErrorOr<types::TypeId> substitute_typevars_in_type(types::TypeId const type_id, types::GenericInferences const generic_inferences);
+DeprecatedString get_argument_name(JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const arg) const;
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::TypeId,types::ScopeId>>> find_type_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
 ErrorOr<types::FunctionId> typecheck_and_specialize_generic_function(types::FunctionId const function_id, JaktInternal::DynamicArray<types::TypeId> const generic_arguments, types::ScopeId const parent_scope_id, JaktInternal::Optional<types::TypeId> const this_type_id, types::GenericInferences const generic_substitutions, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedType>> const type_args, utility::Span const call_span, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>>> const args);
-ErrorOr<types::TypeId> strip_optional_from_type(types::TypeId const type_id);
-ErrorOr<bool> is_scope_directly_accessible_from(types::ScopeId const scope_id, types::ScopeId const from_scope_id) const;
-ErrorOr<void> specialize_trait(types::TraitId const trait_id, JaktInternal::DynamicArray<types::TypeId> const generic_parameters);
-NonnullRefPtr<types::CheckedTrait> get_trait(types::TraitId const id) const;
+ErrorOr<JaktInternal::Optional<types::ScopeId>> required_scope_id_in_hierarchy_for(NonnullRefPtr<typename types::CheckedExpression> const expr, types::ScopeId const current_scope_id);
 NonnullRefPtr<types::CheckedFunction> get_function(types::FunctionId const id) const;
-ErrorOr<JaktInternal::Optional<types::FunctionId>> typecheck_method(parser::ParsedFunction const func, types::StructLikeId const parent_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_var_decl(parser::ParsedVarDecl const var, NonnullRefPtr<typename parser::ParsedExpression> const init, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<JaktInternal::Optional<parser::ParsedNamespace>> lex_and_parse_file_contents(utility::FileId const file_id);
-ErrorOr<types::TypeId> resolve_type_var(types::TypeId const type_var_type_id, types::ScopeId const scope_id) const;
-ErrorOr<JaktInternal::Optional<types::TraitId>> find_trait_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
-ErrorOr<bool> find_and_import_name_from_scope(DeprecatedString const from_name, utility::Span const from_span, DeprecatedString const to_name, utility::Span const to_span, types::ScopeId const from_scope_id, types::ScopeId const into_scope_id, typechecker::ImportRestrictions const allow);
-ErrorOr<void> typecheck_extern_import(parser::ParsedExternImport const import_, types::ScopeId const scope_id);
-NonnullRefPtr<types::CheckedVariable> get_variable(types::VarId const id) const;
-ErrorOr<void> error(DeprecatedString const message, utility::Span const span);
-ErrorOr<JaktInternal::DynamicArray<types::FunctionId>> resolve_call(parser::ParsedCall const call, JaktInternal::DynamicArray<types::ResolvedNamespace> namespaces, utility::Span const span, types::ScopeId const scope_id, bool const must_be_enum_constructor);
-static ErrorOr<typechecker::Typechecker> typecheck(NonnullRefPtr<compiler::Compiler> compiler, parser::ParsedNamespace const parsed_namespace);
-ErrorOr<bool> add_enum_to_scope(types::ScopeId const scope_id, DeprecatedString const name, types::EnumId const enum_id, utility::Span const span);
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> find_scoped_functions_with_name_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_if(NonnullRefPtr<typename parser::ParsedExpression> const condition, parser::ParsedBlock const then_block, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const else_statement, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<types::CheckedVisibility> typecheck_visibility(parser::Visibility const visibility, types::ScopeId const scope_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_destructuring_assignment(JaktInternal::DynamicArray<parser::ParsedVarDecl> const vars, NonnullRefPtr<typename parser::ParsedStatement> const var_decl, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<JaktInternal::Optional<typechecker::TraitImplementationDescriptor>> find_any_singular_trait_implementation(types::TypeId const type_id, JaktInternal::DynamicArray<DeprecatedString> const trait_names, types::ScopeId const scope_id, utility::Span const span);
+ErrorOr<void> specialize_trait(types::TraitId const trait_id, JaktInternal::DynamicArray<types::TypeId> const generic_parameters);
+ErrorOr<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>>> typecheck_match_variant(parser::ParsedMatchCase const case_, types::TypeId const subject_type_id, size_t const variant_index, JaktInternal::Optional<types::TypeId> const final_result_type, types::CheckedEnumVariant const variant, JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const variant_arguments, JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const default_bindings, utility::Span const arguments_span, types::ScopeId const scope_id, types::SafetyMode const safety_mode);
+ErrorOr<void> include_prelude();
+ErrorOr<types::ModuleId> create_module(DeprecatedString const name, bool const is_root, JaktInternal::Optional<DeprecatedString> const path);
 types::ScopeId prelude_scope_id() const;
-ErrorOr<JaktInternal::Optional<types::TypeId>> find_type_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_namespaced_var_or_simple_enum_constructor_call(DeprecatedString const name, JaktInternal::DynamicArray<DeprecatedString> const namespace_, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint, utility::Span const span);
+ErrorOr<void> typecheck_struct_predecl(parser::ParsedRecord const parsed_record, types::StructId const struct_id, types::ScopeId const scope_id);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_unary_operation(NonnullRefPtr<typename types::CheckedExpression> const checked_expr, types::CheckedUnaryOperator const checked_op, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> infer_unsigned_int(u64 const val, utility::Span const span, JaktInternal::Optional<types::TypeId> const type_hint);
+ErrorOr<types::TypeId> strip_optional_from_type(types::TypeId const type_id);
 ErrorOr<JaktInternal::Optional<types::FieldRecord>> lookup_struct_field(types::StructId const struct_id, DeprecatedString const name) const;
-ErrorOr<types::ScopeId> create_scope(JaktInternal::Optional<types::ScopeId> const parent_scope_id, bool const can_throw, DeprecatedString const debug_name, bool const for_block);
-types::CheckedEnum get_enum(types::EnumId const id) const;
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_try_block(NonnullRefPtr<typename parser::ParsedStatement> const stmt, DeprecatedString const error_name, utility::Span const error_span, parser::ParsedBlock const catch_block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<types::CheckedUnaryOperator> typecheck_is_enum_variant(NonnullRefPtr<typename types::CheckedExpression> const checked_expr, NonnullRefPtr<typename parser::ParsedType> const inner, JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const bindings, types::ScopeId const scope_id);
-ErrorOr<types::TypeId> find_type_in_prelude(DeprecatedString const name) const;
-types::TypeId infer_function_return_type(types::CheckedBlock const block) const;
-ErrorOr<JaktInternal::Optional<types::Value>> find_comptime_binding_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_statement(NonnullRefPtr<typename parser::ParsedStatement> const statement, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
-ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>>> resolve_default_params(JaktInternal::DynamicArray<types::CheckedParameter> const params, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const args, types::ScopeId const scope_id, types::SafetyMode const safety_mode, size_t const arg_offset, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_expression(NonnullRefPtr<typename parser::ParsedExpression> const expr, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
-ErrorOr<void> typecheck_struct_constructor(parser::ParsedRecord const parsed_record, types::StructId const struct_id, types::ScopeId const scope_id);
-ErrorOr<void> typecheck_enum_predecl_initial(parser::ParsedRecord const parsed_record, size_t const enum_index, size_t const module_enum_len, types::ScopeId const scope_id);
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>>> find_functions_with_name_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
 ErrorOr<types::CheckedParameter> typecheck_parameter(parser::ParsedParameter const parameter, types::ScopeId const scope_id, bool const first, JaktInternal::Optional<types::TypeId> const this_arg_type_id, JaktInternal::Optional<types::ScopeId> const check_scope);
-ErrorOr<types::TypeId> typecheck_generic_resolved_type(DeprecatedString const name, JaktInternal::DynamicArray<types::TypeId> const checked_inner_types, types::ScopeId const scope_id, utility::Span const span);
+ErrorOr<JaktInternal::Optional<types::TypeId>> unify(types::TypeId const lhs, utility::Span const lhs_span, types::TypeId const rhs, utility::Span const rhs_span);
 types::BlockControlFlow maybe_statement_control_flow(JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> const statement, types::BlockControlFlow const other_branch) const;
-ErrorOr<void> typecheck_jakt_main(parser::ParsedFunction const parsed_function, types::ScopeId const parent_scope_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_for(DeprecatedString const iterator_name, utility::Span const name_span, bool const is_destructuring, NonnullRefPtr<typename parser::ParsedExpression> const range, parser::ParsedBlock const block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<void> typecheck_namespace_constructors(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
 bool is_floating(types::TypeId const type_id) const;
-ErrorOr<JaktInternal::Tuple<types::CheckedMatchBody,JaktInternal::Optional<types::TypeId>>> typecheck_match_body(parser::ParsedMatchBody const body, types::ScopeId const scope_id, types::SafetyMode const safety_mode, types::GenericInferences& generic_inferences, JaktInternal::Optional<types::TypeId> const final_result_type, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_throw(NonnullRefPtr<typename parser::ParsedExpression> const expr, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_set(JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const values, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
-bool is_integer(types::TypeId const type_id) const;
+ErrorOr<JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>>> find_var_in_scope(types::ScopeId const scope_id, DeprecatedString const var) const;
+ErrorOr<void> set_owner_scope_if_needed(types::ScopeId const parent_scope_id, JaktInternal::DynamicArray<types::FunctionId> const overload_set);
+ErrorOr<void> set_owner_scope_if_needed(types::ScopeId const parent_scope_id, types::VarId const var_id);
+ErrorOr<bool> add_type_to_scope(types::ScopeId const scope_id, DeprecatedString const type_name, types::TypeId const type_id, utility::Span const span);
+ErrorOr<types::TypeId> find_type_in_prelude(DeprecatedString const name) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> infer_signed_int(i64 const val, utility::Span const span, JaktInternal::Optional<types::TypeId> const type_hint);
 ErrorOr<void> typecheck_namespace_aliases(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id, typechecker::ImportRestrictions const allow);
+ErrorOr<bool> add_struct_to_scope(types::ScopeId const scope_id, DeprecatedString const name, types::StructId const struct_id, utility::Span const span);
+ErrorOr<void> error(DeprecatedString const message, utility::Span const span);
+ErrorOr<bool> check_restricted_access(types::ScopeId const accessor, DeprecatedString const accessee_kind, types::ScopeId const accessee, DeprecatedString const name, JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> const whitelist, utility::Span const span);
+ErrorOr<bool> check_types_for_compat(types::TypeId const lhs_type_id, types::TypeId const rhs_type_id, types::GenericInferences& generic_inferences, utility::Span const span);
+ErrorOr<void> typecheck_enum_predecl(parser::ParsedRecord const parsed_record, types::EnumId const enum_id, types::ScopeId const scope_id);
+ErrorOr<void> check_member_access(types::ScopeId const accessor, types::ScopeId const accessee, NonnullRefPtr<types::CheckedVariable> const member, utility::Span const span);
+bool is_integer(types::TypeId const type_id) const;
+ErrorOr<bool> signatures_match(types::TypeId const self_type_id, NonnullRefPtr<types::CheckedFunction> const first, NonnullRefPtr<types::CheckedFunction> const second);
+ErrorOr<NonnullRefPtr<typename types::Type>> unwrap_type_from_optional_if_needed(NonnullRefPtr<typename types::Type> const type) const;
 ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_guard(NonnullRefPtr<typename parser::ParsedExpression> const expr, parser::ParsedBlock const else_block, parser::ParsedBlock const remaining_code, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<bool> add_comptime_binding_to_scope(types::ScopeId const scope_id, DeprecatedString const name, types::Value const value, utility::Span const span);
+NonnullRefPtr<typename types::Type> get_type(types::TypeId const id) const;
 ErrorOr<bool> add_trait_to_scope(types::ScopeId const scope_id, DeprecatedString const trait_name, types::TraitId const trait_id, utility::Span const span);
-ErrorOr<bool> signatures_match(types::TypeId const self_type_id, NonnullRefPtr<types::CheckedFunction> const first, NonnullRefPtr<types::CheckedFunction> const second);
-ErrorOr<DeprecatedString> type_name(types::TypeId const type_id, bool const debug_mode) const;
-ErrorOr<JaktInternal::Tuple<JaktInternal::Optional<DeprecatedString>,types::CheckedMatchCase,JaktInternal::Optional<types::TypeId>>> typecheck_match_variant(parser::ParsedMatchCase const case_, types::TypeId const subject_type_id, size_t const variant_index, JaktInternal::Optional<types::TypeId> const final_result_type, types::CheckedEnumVariant const variant, JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const variant_arguments, JaktInternal::Dictionary<DeprecatedString,parser::ParsedPatternDefault> const default_bindings, utility::Span const arguments_span, types::ScopeId const scope_id, types::SafetyMode const safety_mode);
-ErrorOr<void> error_with_hint(DeprecatedString const message, utility::Span const span, DeprecatedString const hint, utility::Span const hint_span);
-ErrorOr<JaktInternal::Optional<typechecker::TraitImplementationDescriptor>> find_singular_trait_implementation(types::TypeId const type_id, DeprecatedString const trait_name, types::ScopeId const scope_id, utility::Span const span);
+ErrorOr<JaktInternal::Optional<types::ScopeId>> scope_lifetime_union(JaktInternal::Optional<types::ScopeId> const first, JaktInternal::Optional<types::ScopeId> const second) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_destructuring_assignment(JaktInternal::DynamicArray<parser::ParsedVarDecl> const vars, NonnullRefPtr<typename parser::ParsedStatement> const var_decl, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<bool> is_scope_directly_accessible_from(types::ScopeId const scope_id, types::ScopeId const from_scope_id) const;
+ErrorOr<void> typecheck_struct_default_fields(parser::ParsedRecord const parsed_record, types::StructId const struct_id, types::ScopeId const scope_id);
+ErrorOr<void> typecheck_namespace_constructors(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_block_statement(parser::ParsedBlock const parsed_block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<types::FunctionId> typecheck_function_predecl(parser::ParsedFunction const parsed_function, types::ScopeId const parent_scope_id, JaktInternal::Optional<types::TypeId> const this_arg_type_id, JaktInternal::Optional<NonnullRefPtr<types::FunctionGenerics>> generics);
 ErrorOr<types::TypeId> find_or_add_type_id(NonnullRefPtr<typename types::Type> const type);
+static ErrorOr<typechecker::Typechecker> typecheck(NonnullRefPtr<compiler::Compiler> compiler, parser::ParsedNamespace const parsed_namespace);
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>>> typecheck_enum_variant_bindings(types::CheckedEnumVariant const variant, JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const bindings, utility::Span const span);
+ErrorOr<void> typecheck_struct(parser::ParsedRecord const record, types::StructId const struct_id, types::ScopeId const parent_scope_id);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_lambda(JaktInternal::DynamicArray<parser::ParsedCapture> const captures, JaktInternal::DynamicArray<parser::ParsedParameter> const params, bool const can_throw, bool const is_fat_arrow, NonnullRefPtr<typename parser::ParsedType> const return_type, parser::ParsedBlock const block, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode);
+NonnullRefPtr<types::CheckedVariable> get_variable(types::VarId const id) const;
+ErrorOr<JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename types::CheckedExpression>>>> resolve_default_params(JaktInternal::DynamicArray<types::CheckedParameter> const params, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>>> const args, types::ScopeId const scope_id, types::SafetyMode const safety_mode, size_t const arg_offset, utility::Span const span);
+ErrorOr<JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>>> find_all_implementations_of_trait(types::TypeId const type_id, types::TraitId const trait_id);
 ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>>> find_namespace_in_scope(types::ScopeId const scope_id, DeprecatedString const name, bool const treat_aliases_as_imports) const;
-ErrorOr<void> typecheck_enum_predecl(parser::ParsedRecord const parsed_record, types::EnumId const enum_id, types::ScopeId const scope_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> dereference_if_needed(NonnullRefPtr<typename types::CheckedExpression> const checked_expr, utility::Span const span);
-DeprecatedString get_argument_name(JaktInternal::Tuple<DeprecatedString,utility::Span,NonnullRefPtr<typename parser::ParsedExpression>> const arg) const;
-types::ScopeId root_scope_id() const;
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_unary_operation(NonnullRefPtr<typename types::CheckedExpression> const checked_expr, types::CheckedUnaryOperator const checked_op, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode);
-ErrorOr<types::TypeId> final_type_resolution_form(types::TypeId const type_id, types::ScopeId const scope_id) const;
-ErrorOr<void> typecheck_namespace_declarations(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
-ErrorOr<JaktInternal::Optional<typechecker::TraitImplementationDescriptor>> find_any_singular_trait_implementation(types::TypeId const type_id, JaktInternal::DynamicArray<DeprecatedString> const trait_names, types::ScopeId const scope_id, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_defer(NonnullRefPtr<typename parser::ParsedStatement> const statement, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> cast_to_underlying(NonnullRefPtr<typename parser::ParsedExpression> const expr, types::ScopeId const scope_id, NonnullRefPtr<typename parser::ParsedType> const parsed_type);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_comptime_index(NonnullRefPtr<typename parser::ParsedExpression> const expr, NonnullRefPtr<typename parser::ParsedExpression> const index, types::ScopeId const scope_id, bool const is_optional, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<void> typecheck_struct_default_fields(parser::ParsedRecord const parsed_record, types::StructId const struct_id, types::ScopeId const scope_id);
-ErrorOr<bool> scope_lifetime_subsumes(JaktInternal::Optional<types::ScopeId> const larger, JaktInternal::Optional<types::ScopeId> const smaller, JaktInternal::Set<DeprecatedString>& checked) const;
-ErrorOr<bool> scope_lifetime_subsumes(JaktInternal::Optional<types::ScopeId> const larger, JaktInternal::Optional<types::ScopeId> const smaller) const;
-ErrorOr<void> check_method_access(types::ScopeId const accessor, types::ScopeId const accessee, NonnullRefPtr<types::CheckedFunction> const method, utility::Span const span);
-ErrorOr<types::CheckedBlock> typecheck_block(parser::ParsedBlock const parsed_block, types::ScopeId const parent_scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const yield_type_hint);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_loop(parser::ParsedBlock const parsed_block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_generic_arguments_method_call(NonnullRefPtr<typename types::CheckedExpression> const checked_expr, parser::ParsedCall const call, types::ScopeId const scope_id, utility::Span const span, bool const is_optional, types::SafetyMode const safety_mode);
-ErrorOr<bool> check_restricted_access(types::ScopeId const accessor, DeprecatedString const accessee_kind, types::ScopeId const accessee, DeprecatedString const name, JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> const whitelist, utility::Span const span);
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>>> get_type_ids_from_type_hint_if_struct_ids_match(JaktInternal::Optional<types::TypeId> const type_hint, types::StructId const expected_struct_id) const;
-ErrorOr<JaktInternal::DynamicArray<types::StructId>> struct_inheritance_chain(types::StructId const struct_id) const;
-ErrorOr<bool> add_function_to_scope(types::ScopeId const parent_scope_id, DeprecatedString const name, JaktInternal::DynamicArray<types::FunctionId> const overload_set, utility::Span const span);
+ErrorOr<void> typecheck_struct_fields(parser::ParsedRecord const record, types::StructId const struct_id);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_call(parser::ParsedCall const call, types::ScopeId const caller_scope_id, utility::Span const span, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const this_expr, JaktInternal::Optional<types::StructLikeId> const parent_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> type_hint, bool const must_be_enum_constructor);
+ErrorOr<JaktInternal::DynamicArray<types::FunctionId>> resolve_call(parser::ParsedCall const call, JaktInternal::DynamicArray<types::ResolvedNamespace> namespaces, utility::Span const span, types::ScopeId const scope_id, bool const must_be_enum_constructor);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_if(NonnullRefPtr<typename parser::ParsedExpression> const condition, parser::ParsedBlock const then_block, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const else_statement, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<void> check_implicit_constructor_argument_access(types::ScopeId const caller_scope_id, parser::ParsedCall const call, types::CheckedStruct const struct_);
 ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_expression_and_dereference_if_needed(NonnullRefPtr<typename parser::ParsedExpression> const expr, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint, utility::Span const span);
-ErrorOr<jakt__path::Path> get_root_path() const;
+ErrorOr<void> typecheck_enum(parser::ParsedRecord const record, types::EnumId const enum_id, types::ScopeId const parent_scope_id);
+ErrorOr<JaktInternal::Optional<types::TypeId>> find_type_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+ErrorOr<JaktInternal::Optional<types::CheckedEnumVariant>> get_enum_variant(types::CheckedEnum const enum_, DeprecatedString const variant_name);
 ErrorOr<bool> scope_can_access(types::ScopeId const accessor, types::ScopeId const accessee) const;
-ErrorOr<typechecker::FunctionMatchResult> match_function_and_resolve_args(parser::ParsedCall const call, types::ScopeId const caller_scope_id, types::FunctionId const candidate, types::SafetyMode const safety_mode, utility::Span const span, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const this_expr);
-ErrorOr<void> dump_type_hint(types::TypeId const type_id, utility::Span const span) const;
-ErrorOr<void> typecheck_namespace_default_fields(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
-ErrorOr<void> typecheck_namespace_imports(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
-ErrorOr<types::TypeId> typecheck_typename(NonnullRefPtr<typename parser::ParsedType> const parsed_type, types::ScopeId const scope_id, JaktInternal::Optional<DeprecatedString> const name);
-ErrorOr<JaktInternal::Optional<types::TypeId>> unify(types::TypeId const lhs, utility::Span const lhs_span, types::TypeId const rhs, utility::Span const rhs_span);
-bool is_numeric(types::TypeId const type_id) const;
-ErrorOr<bool> add_type_to_scope(types::ScopeId const scope_id, DeprecatedString const type_name, types::TypeId const type_id, utility::Span const span);
-ErrorOr<bool> add_var_to_scope(types::ScopeId const scope_id, DeprecatedString const name, types::VarId const var_id, utility::Span const span);
-ErrorOr<JaktInternal::Optional<types::ScopeId>> required_scope_id_in_hierarchy_for(NonnullRefPtr<typename types::CheckedExpression> const expr, types::ScopeId const current_scope_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_try(NonnullRefPtr<typename parser::ParsedExpression> const expr, JaktInternal::Optional<parser::ParsedBlock> const catch_block, JaktInternal::Optional<DeprecatedString> const catch_name, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span, JaktInternal::Optional<types::TypeId> const type_hint);
-ErrorOr<void> include_prelude();
-ErrorOr<void> typecheck_namespace_fields(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_while(NonnullRefPtr<typename parser::ParsedExpression> const condition, parser::ParsedBlock const block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<void> fill_trait_implementation_list(JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> const parsed_impl_list, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>>& trait_implementations, types::ScopeId const scope_id, JaktInternal::Optional<types::ScopeId> const trait_name_scope_id_override);
-ErrorOr<void> typecheck_struct_predecl(parser::ParsedRecord const parsed_record, types::StructId const struct_id, types::ScopeId const scope_id);
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::TypeId,types::ScopeId>>> find_type_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
-ErrorOr<NonnullRefPtr<interpreter::Interpreter>> interpreter();
-ErrorOr<void> check_member_access(types::ScopeId const accessor, types::ScopeId const accessee, NonnullRefPtr<types::CheckedVariable> const member, utility::Span const span);
-ErrorOr<bool> add_struct_to_scope(types::ScopeId const scope_id, DeprecatedString const name, types::StructId const struct_id, utility::Span const span);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> infer_unsigned_int(u64 const val, utility::Span const span, JaktInternal::Optional<types::TypeId> const type_hint);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_unary_negate(NonnullRefPtr<typename types::CheckedExpression> const expr, utility::Span const span, types::TypeId const type_id);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_dictionary(JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,NonnullRefPtr<typename parser::ParsedExpression>>> const values, utility::Span const span, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
-ErrorOr<void> typecheck_alias(parser::ParsedAlias const alias, types::ScopeId const scope_id, typechecker::ImportRestrictions const allow);
-ErrorOr<types::TypeId> unify_with_type(types::TypeId const found_type, JaktInternal::Optional<types::TypeId> const expected_type, utility::Span const span);
+ErrorOr<JaktInternal::DynamicArray<types::StructId>> struct_inheritance_chain(types::StructId const struct_id) const;
+ErrorOr<bool> type_contains_reference(types::TypeId const type_id);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_for(DeprecatedString const iterator_name, utility::Span const name_span, bool const is_destructuring, NonnullRefPtr<typename parser::ParsedExpression> const range, parser::ParsedBlock const block, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<JaktInternal::Optional<types::FunctionId>> find_function_matching_signature_in_scope(types::ScopeId const parent_scope_id, parser::ParsedFunction const prototype) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_array(types::ScopeId const scope_id, JaktInternal::DynamicArray<NonnullRefPtr<typename parser::ParsedExpression>> const values, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const fill_size, utility::Span const span, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
 ErrorOr<void> typecheck_trait_predecl(parser::ParsedTrait const parsed_trait, types::ScopeId const scope_id);
+ErrorOr<bool> implements_trait(types::TypeId const type_id, types::TraitId const trait_id, JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const generic_arguments);
+ErrorOr<void> typecheck_module_import(parser::ParsedModuleImport const import_, types::ScopeId const scope_id);
+ErrorOr<JaktInternal::Optional<types::FunctionId>> typecheck_method(parser::ParsedFunction const func, types::StructLikeId const parent_id);
+ErrorOr<void> typecheck_extern_import(parser::ParsedExternImport const import_, types::ScopeId const scope_id);
 types::BlockControlFlow statement_control_flow(NonnullRefPtr<typename types::CheckedStatement> const statement) const;
-ErrorOr<JaktInternal::Optional<types::FunctionId>> find_function_matching_signature_in_scope(types::ScopeId const parent_scope_id, parser::ParsedFunction const prototype) const;
-ErrorOr<void> map_generic_arguments(types::TypeId const type_id, JaktInternal::DynamicArray<types::TypeId> const args);
+ErrorOr<JaktInternal::Optional<types::StructId>> find_struct_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+ErrorOr<JaktInternal::Optional<parser::ParsedNamespace>> lex_and_parse_file_contents(utility::FileId const file_id);
+ErrorOr<void> check_that_type_doesnt_contain_reference(types::TypeId const type_id, utility::Span const span);
+ErrorOr<bool> find_and_import_name_from_scope(DeprecatedString const from_name, utility::Span const from_span, DeprecatedString const to_name, utility::Span const to_span, types::ScopeId const from_scope_id, types::ScopeId const into_scope_id, typechecker::ImportRestrictions const allow);
 ErrorOr<bool> validate_argument_label(types::CheckedParameter const param, DeprecatedString const label, utility::Span const span, NonnullRefPtr<typename parser::ParsedExpression> const expr, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const default_value);
-ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> infer_signed_int(i64 const val, utility::Span const span, JaktInternal::Optional<types::TypeId> const type_hint);
-NonnullRefPtr<typename types::Type> get_type(types::TypeId const id) const;
+ErrorOr<bool> add_enum_to_scope(types::ScopeId const scope_id, DeprecatedString const name, types::EnumId const enum_id, utility::Span const span);
+ErrorOr<JaktInternal::Tuple<NonnullRefPtr<typename parser::ParsedExpression>,JaktInternal::Optional<parser::ParsedBlock>,JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>>>> expand_context_for_bindings(NonnullRefPtr<typename parser::ParsedExpression> const condition, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> const acc, JaktInternal::Optional<parser::ParsedBlock> const then_block, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedStatement>> const else_statement, utility::Span const span);
+ErrorOr<JaktInternal::Optional<types::TraitId>> find_trait_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+NonnullRefPtr<types::Module> current_module() const;
+types::ScopeId root_scope_id() const;
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_defer(NonnullRefPtr<typename parser::ParsedStatement> const statement, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+ErrorOr<bool> add_function_to_scope(types::ScopeId const parent_scope_id, DeprecatedString const name, JaktInternal::DynamicArray<types::FunctionId> const overload_set, utility::Span const span);
+ErrorOr<void> check_method_access(types::ScopeId const accessor, types::ScopeId const accessee, NonnullRefPtr<types::CheckedFunction> const method, utility::Span const span);
+ErrorOr<types::TypeId> final_type_resolution_form(types::TypeId const type_id, types::ScopeId const scope_id) const;
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> find_scoped_functions_with_name_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
+ErrorOr<NonnullRefPtr<interpreter::Interpreter>> interpreter();
+ErrorOr<void> dump_try_hint(utility::Span const span) const;
+ErrorOr<void> typecheck_module(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
+ErrorOr<void> error_with_hint(DeprecatedString const message, utility::Span const span, DeprecatedString const hint, utility::Span const hint_span);
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_var_decl(parser::ParsedVarDecl const var, NonnullRefPtr<typename parser::ParsedExpression> const init, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span);
+bool is_subclass_of(types::TypeId const ancestor_type_id, types::TypeId const child_type_id) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedStatement>> typecheck_inline_cpp(parser::ParsedBlock const block, utility::Span const span, types::SafetyMode const safety_mode);
+ErrorOr<void> typecheck_namespace_predecl(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
+bool is_struct(types::TypeId const type_id) const;
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_expression(NonnullRefPtr<typename parser::ParsedExpression> const expr, types::ScopeId const scope_id, types::SafetyMode const safety_mode, JaktInternal::Optional<types::TypeId> const type_hint);
 ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_indexed_struct(NonnullRefPtr<typename parser::ParsedExpression> const expr, DeprecatedString const field_name, types::ScopeId const scope_id, bool const is_optional, types::SafetyMode const safety_mode, utility::Span const span);
-ErrorOr<types::FunctionId> typecheck_function_predecl(parser::ParsedFunction const parsed_function, types::ScopeId const parent_scope_id, JaktInternal::Optional<types::TypeId> const this_arg_type_id, JaktInternal::Optional<NonnullRefPtr<types::FunctionGenerics>> generics);
-ErrorOr<bool> type_contains_reference(types::TypeId const type_id);
-ErrorOr<types::ModuleId> create_module(DeprecatedString const name, bool const is_root, JaktInternal::Optional<DeprecatedString> const path);
-ErrorOr<void> set_owner_scope_if_needed(types::ScopeId const parent_scope_id, JaktInternal::DynamicArray<types::FunctionId> const overload_set);
-ErrorOr<void> set_owner_scope_if_needed(types::ScopeId const parent_scope_id, types::VarId const var_id);
-ErrorOr<void> typecheck_namespace_function_predecl(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
-ErrorOr<void> typecheck_enum_constructor(parser::ParsedRecord const parsed_record, types::EnumId const enum_id, types::ScopeId const parent_scope_id);
-ErrorOr<void> typecheck_enum(parser::ParsedRecord const record, types::EnumId const enum_id, types::ScopeId const parent_scope_id);
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::CheckedEnumVariantBinding>>> typecheck_enum_variant_bindings(types::CheckedEnumVariant const variant, JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> const bindings, utility::Span const span);
-ErrorOr<bool> implements_trait(types::TypeId const type_id, types::TraitId const trait_id, JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const generic_arguments);
-ErrorOr<JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>>> find_var_in_scope(types::ScopeId const scope_id, DeprecatedString const var) const;
-ErrorOr<void> typecheck_struct(parser::ParsedRecord const record, types::StructId const struct_id, types::ScopeId const parent_scope_id);
-ErrorOr<void> typecheck_struct_predecl_initial(parser::ParsedRecord const parsed_record, size_t const struct_index, size_t const module_struct_len, types::ScopeId const scope_id);
-ErrorOr<void> fill_trait_requirements(JaktInternal::DynamicArray<parser::ParsedNameWithGenericParameters> const names, JaktInternal::DynamicArray<types::TraitId>& trait_requirements, JaktInternal::DynamicArray<types::TypeId>& trait_implementations, types::ScopeId const scope_id);
+ErrorOr<void> typecheck_namespace_imports(parser::ParsedNamespace const parsed_namespace, types::ScopeId const scope_id);
+ErrorOr<jakt__path::Path> get_root_path() const;
+ErrorOr<JaktInternal::Optional<typechecker::TraitImplementationDescriptor>> find_singular_trait_implementation(types::TypeId const type_id, DeprecatedString const trait_name, types::ScopeId const scope_id, utility::Span const span);
+ErrorOr<NonnullRefPtr<typename types::CheckedExpression>> typecheck_try(NonnullRefPtr<typename parser::ParsedExpression> const expr, JaktInternal::Optional<parser::ParsedBlock> const catch_block, JaktInternal::Optional<DeprecatedString> const catch_name, types::ScopeId const scope_id, types::SafetyMode const safety_mode, utility::Span const span, JaktInternal::Optional<types::TypeId> const type_hint);
+ErrorOr<types::TypeId> typecheck_typename(NonnullRefPtr<typename parser::ParsedType> const parsed_type, types::ScopeId const scope_id, JaktInternal::Optional<DeprecatedString> const name);
+types::TypeId infer_function_return_type(types::CheckedBlock const block) const;
+ErrorOr<bool> scope_lifetime_subsumes(JaktInternal::Optional<types::ScopeId> const larger, JaktInternal::Optional<types::ScopeId> const smaller, JaktInternal::Set<DeprecatedString>& checked) const;
+ErrorOr<bool> scope_lifetime_subsumes(JaktInternal::Optional<types::ScopeId> const larger, JaktInternal::Optional<types::ScopeId> const smaller) const;
 ErrorOr<DeprecatedString> debug_description() const;
-};struct TraitImplCheck {
+};struct ImportRestrictions {
   public:
-JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> missing_methods;JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> unmatched_signatures;JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> private_matching_methods;JaktInternal::Dictionary<DeprecatedString,typechecker::AlreadyImplementedFor> already_implemented_for;ErrorOr<void> ensure_capacity(size_t const count);
-static ErrorOr<typechecker::TraitImplCheck> make();
-TraitImplCheck(JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,types::FunctionId>> a_missing_methods, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> a_unmatched_signatures, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Dictionary<DeprecatedString,utility::Span>> a_private_matching_methods, JaktInternal::Dictionary<DeprecatedString,typechecker::AlreadyImplementedFor> a_already_implemented_for);
+bool functions;bool structs;bool enums;bool types;bool traits;bool namespaces;ImportRestrictions(bool a_functions, bool a_structs, bool a_enums, bool a_types, bool a_traits, bool a_namespaces);
 
-ErrorOr<void> register_trait(types::TraitId const trait_id, DeprecatedString const trait_name, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> const trait_methods);
-ErrorOr<void> register_method(types::TypeId const self_type_id, DeprecatedString const method_name, types::FunctionId const method_id, typechecker::Typechecker& typechecker);
-ErrorOr<void> throw_errors(utility::Span const record_decl_span, typechecker::Typechecker& typechecker);
+static typechecker::ImportRestrictions all();
 ErrorOr<DeprecatedString> debug_description() const;
 };struct AlreadyImplementedFor {
   public:
 DeprecatedString trait_name;utility::Span encounter_span;AlreadyImplementedFor(DeprecatedString a_trait_name, utility::Span a_encounter_span);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};struct ImportRestrictions {
-  public:
-bool functions;bool structs;bool enums;bool types;bool traits;bool namespaces;ImportRestrictions(bool a_functions, bool a_structs, bool a_enums, bool a_types, bool a_traits, bool a_namespaces);
-
-static typechecker::ImportRestrictions all();
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace FunctionMatchResult_Details {
-struct MatchSuccess {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> args;
-JaktInternal::Optional<types::TypeId> maybe_this_type_id;
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> used_generic_inferences;
-i64 specificity;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-MatchSuccess(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-args{ forward<_MemberT0>(member_0)},
-maybe_this_type_id{ forward<_MemberT1>(member_1)},
-used_generic_inferences{ forward<_MemberT2>(member_2)},
-specificity{ forward<_MemberT3>(member_3)}
-{}
-};
-struct MatchError {
-JaktInternal::DynamicArray<error::JaktError> errors;
-template<typename _MemberT0>
-MatchError(_MemberT0&& member_0):
-errors{ forward<_MemberT0>(member_0)}
-{}
-};
-}
-struct FunctionMatchResult : public Variant<FunctionMatchResult_Details::MatchSuccess, FunctionMatchResult_Details::MatchError> {
-using Variant<FunctionMatchResult_Details::MatchSuccess, FunctionMatchResult_Details::MatchError>::Variant;
-    using MatchSuccess = FunctionMatchResult_Details::MatchSuccess;
-    using MatchError = FunctionMatchResult_Details::MatchError;
-ErrorOr<DeprecatedString> debug_description() const;
-};
-}
+};}
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::typechecker::NumericOrStringValue> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::NumericOrStringValue const& value) {
+template<>struct Jakt::Formatter<Jakt::typechecker::TraitImplementationDescriptor> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::TraitImplementationDescriptor const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::typechecker::TraitImplementationDescriptor> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::TraitImplementationDescriptor const& value) {
+template<>struct Jakt::Formatter<Jakt::typechecker::FunctionMatchResult> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::FunctionMatchResult const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::typechecker::Typechecker> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::Typechecker const& value) {
+template<>struct Jakt::Formatter<Jakt::typechecker::NumericOrStringValue> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::NumericOrStringValue const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
@@ -293,8 +293,8 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::typechecker::AlreadyImplementedFor> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::AlreadyImplementedFor const& value) {
+template<>struct Jakt::Formatter<Jakt::typechecker::Typechecker> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::Typechecker const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
@@ -305,8 +305,8 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::typechecker::FunctionMatchResult> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::FunctionMatchResult const& value) {
+template<>struct Jakt::Formatter<Jakt::typechecker::AlreadyImplementedFor> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::typechecker::AlreadyImplementedFor const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
diff --git a/bootstrap/stage0/types.cpp b/bootstrap/stage0/types.cpp
index 34f4e71d7..955a528df 100644
--- a/bootstrap/stage0/types.cpp
+++ b/bootstrap/stage0/types.cpp
@@ -82,6 +82,20 @@ return (false);
 }
 }
 
+ErrorOr<DeprecatedString> types::StructId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("StructId("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::StructId::StructId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
+
+bool types::StructId::equals(types::StructId const rhs) const {
+{
+return (((((((*this).module)).id) == ((((rhs).module)).id)) && (((*this).id) == ((rhs).id))));
+}
+}
+
 ErrorOr<DeprecatedString> types::CheckedStringLiteral::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedStringLiteral("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("value: {}, ", value));
@@ -102,53 +116,6 @@ JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("values: {}", values));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-DeprecatedString types::GenericInferences::map_name(DeprecatedString const type) const {
-{
-JaktInternal::Optional<DeprecatedString> mapped = ((((*this).values)).get(type));
-JaktInternal::Optional<DeprecatedString> final_mapped_result = mapped;
-while (((mapped).has_value())){
-(final_mapped_result = mapped);
-(mapped = ((((*this).values)).get((mapped.value()))));
-}
-return (final_mapped_result.value_or_lazy_evaluated([&] { return type; }));
-}
-}
-
-types::GenericInferences::GenericInferences(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> a_values) :values(move(a_values)){}
-
-void types::GenericInferences::restore(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint) {
-{
-(((*this).values) = checkpoint);
-}
-}
-
-ErrorOr<types::TypeId> types::GenericInferences::map(types::TypeId const type_id) const {
-{
-return (TRY((types::TypeId::from_string(((*this).map_name(TRY((((type_id).to_string())))))))));
-}
-}
-
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> types::GenericInferences::iterator() const {
-{
-return (((*this).values));
-}
-}
-
-ErrorOr<void> types::GenericInferences::set(DeprecatedString const key,DeprecatedString const value) {
-{
-if ((key == value)){
-outln(Jakt::DeprecatedString("Warning: Generic parameter {} is being bound to itself"sv),key);
-abort();
-}
-DeprecatedString const mapped_value = ((*this).map_name(value));
-if ((key == mapped_value)){
-return {};
-}
-TRY(((*this).values).set(key, mapped_value));
-}
-return {};
-}
-
 ErrorOr<void> types::GenericInferences::set_all(JaktInternal::DynamicArray<types::CheckedGenericParameter> const keys,JaktInternal::DynamicArray<types::TypeId> const values) {
 {
 {
@@ -172,6 +139,18 @@ TRY((((*this).set(key,value))));
 return {};
 }
 
+DeprecatedString types::GenericInferences::map_name(DeprecatedString const type) const {
+{
+JaktInternal::Optional<DeprecatedString> mapped = ((((*this).values)).get(type));
+JaktInternal::Optional<DeprecatedString> final_mapped_result = mapped;
+while (((mapped).has_value())){
+(final_mapped_result = mapped);
+(mapped = ((((*this).values)).get((mapped.value()))));
+}
+return (final_mapped_result.value_or_lazy_evaluated([&] { return type; }));
+}
+}
+
 ErrorOr<void> types::GenericInferences::set_from(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint) {
 {
 {
@@ -197,9 +176,17 @@ TRY(((*this).values).set(key, value));
 return {};
 }
 
-JaktInternal::Optional<DeprecatedString> types::GenericInferences::get(DeprecatedString const key) const {
+types::GenericInferences::GenericInferences(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> a_values) :values(move(a_values)){}
+
+void types::GenericInferences::restore(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint) {
 {
-return (((((*this).values)).get(key)));
+(((*this).values) = checkpoint);
+}
+}
+
+ErrorOr<types::TypeId> types::GenericInferences::map(types::TypeId const type_id) const {
+{
+return (TRY((types::TypeId::from_string(((*this).map_name(TRY((((type_id).to_string())))))))));
 }
 }
 
@@ -232,801 +219,747 @@ return (result);
 }
 }
 
-ErrorOr<DeprecatedString> types::CheckedStruct::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedStruct("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_parameters: {}, ", generic_parameters));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("fields: {}, ", fields));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scope_id: {}, ", scope_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("definition_linkage: {}, ", definition_linkage));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("trait_implementations: {}, ", trait_implementations));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("record_type: {}, ", record_type));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}, ", type_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("super_struct_id: {}, ", super_struct_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}", external_name));
+JaktInternal::Optional<DeprecatedString> types::GenericInferences::get(DeprecatedString const key) const {
+{
+return (((((*this).values)).get(key)));
+}
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedStruct::CheckedStruct(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<types::CheckedField> a_fields, types::ScopeId a_scope_id, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> a_trait_implementations, parser::RecordType a_record_type, types::TypeId a_type_id, JaktInternal::Optional<types::StructId> a_super_struct_id, JaktInternal::Optional<DeprecatedString> a_external_name) :name(move(a_name)), name_span(move(a_name_span)), generic_parameters(move(a_generic_parameters)), fields(move(a_fields)), scope_id(move(a_scope_id)), definition_linkage(move(a_definition_linkage)), trait_implementations(move(a_trait_implementations)), record_type(move(a_record_type)), type_id(move(a_type_id)), super_struct_id(move(a_super_struct_id)), external_name(move(a_external_name)){}
 
-DeprecatedString types::CheckedStruct::name_for_codegen() const {
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> types::GenericInferences::iterator() const {
 {
-return (((*this).external_name).value_or_lazy_evaluated([&] { return ((*this).name); }));
+return (((*this).values));
 }
 }
 
-ErrorOr<DeprecatedString> types::CheckedVariable::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedVariable("sv));{
+ErrorOr<void> types::GenericInferences::set(DeprecatedString const key,DeprecatedString const value) {
+{
+if ((key == value)){
+outln(Jakt::DeprecatedString("Warning: Generic parameter {} is being bound to itself"sv),key);
+abort();
+}
+DeprecatedString const mapped_value = ((*this).map_name(value));
+if ((key == mapped_value)){
+return {};
+}
+TRY(((*this).values).set(key, mapped_value));
+}
+return {};
+}
+
+ErrorOr<DeprecatedString> types::CheckedFunction::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedFunction("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}, ", type_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_mutable: {}, ", is_mutable));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("definition_span: {}, ", definition_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_span: {}, ", type_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("visibility: {}, ", visibility));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("owner_scope: {}", owner_scope));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("return_type_id: {}, ", return_type_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("return_type_span: {}, ", return_type_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("params: {}, ", params));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generics: {}, ", *generics));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("block: {}, ", block));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("can_throw: {}, ", can_throw));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type: {}, ", type));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("linkage: {}, ", linkage));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("function_scope_id: {}, ", function_scope_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("struct_id: {}, ", struct_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_instantiated: {}, ", is_instantiated));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parsed_function: {}, ", parsed_function));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_comptime: {}, ", is_comptime));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_virtual: {}, ", is_virtual));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_override: {}, ", is_override));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("specialization_index: {}, ", specialization_index));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("owner_scope: {}, ", owner_scope));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}, ", external_name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("deprecated_message: {}, ", deprecated_message));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("stores_arguments: {}", stores_arguments));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<NonnullRefPtr<types::CheckedVariable>> types::CheckedVariable::map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) const {
+ErrorOr<void> types::CheckedFunction::map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) {
 {
-return (TRY((types::CheckedVariable::__jakt_create(((*this).name),TRY((map(((*this).type_id)))),((*this).is_mutable),((*this).definition_span),((*this).type_span),((*this).visibility),((*this).owner_scope)))));
+(((*this).return_type_id) = TRY((map(((*this).return_type_id)))));
+JaktInternal::DynamicArray<types::CheckedParameter> changed_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+{
+JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((*this).params)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+types::CheckedParameter param = (_magic_value.value());
+{
+TRY((((changed_params).push(TRY((((param).map_types(map))))))));
 }
 
-types::CheckedVariable::CheckedVariable(DeprecatedString a_name, types::TypeId a_type_id, bool a_is_mutable, utility::Span a_definition_span, JaktInternal::Optional<utility::Span> a_type_span, types::CheckedVisibility a_visibility, JaktInternal::Optional<types::ScopeId> a_owner_scope): name(move(a_name)), type_id(move(a_type_id)), is_mutable(move(a_is_mutable)), definition_span(move(a_definition_span)), type_span(move(a_type_span)), visibility(move(a_visibility)), owner_scope(move(a_owner_scope)){}
-ErrorOr<NonnullRefPtr<CheckedVariable>> types::CheckedVariable::__jakt_create(DeprecatedString name, types::TypeId type_id, bool is_mutable, utility::Span definition_span, JaktInternal::Optional<utility::Span> type_span, types::CheckedVisibility visibility, JaktInternal::Optional<types::ScopeId> owner_scope) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) CheckedVariable (move(name), move(type_id), move(is_mutable), move(definition_span), move(type_span), move(visibility), move(owner_scope)))); return o; }
-ErrorOr<DeprecatedString> types::CheckedProgram::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedProgram("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("modules: {}, ", modules));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("loaded_modules: {}", loaded_modules));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-bool types::CheckedProgram::is_floating(types::TypeId const type_id) const {
-{
-NonnullRefPtr<typename types::Type> const type = ((*this).get_type(type_id));
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *type;
-switch(__jakt_match_variant.index()) {
-case 10: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
 }
 }
 
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> types::CheckedProgram::find_scoped_functions_with_name_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
-{
-return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>(parent_scope_id,(([function_name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> {
-{
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_functions = ((((scope)->functions)).get(function_name));
-if (((maybe_functions).has_value())){
-return ( typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>> { typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>::Break((Tuple{(maybe_functions.value()), scope_id})) } );
+(((*this).params) = changed_params);
 }
-return ( typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>> { typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>::Continue() } );
+return {};
 }
+
+bool types::CheckedFunction::is_static() const {
+{
+if ((((((*this).params)).size()) < static_cast<size_t>(1ULL))){
+return (true);
 }
-)))))));
+return ((((((((((*this).params))[static_cast<i64>(0LL)])).variable))->name) != Jakt::DeprecatedString("this"sv)));
 }
 }
 
-bool types::CheckedProgram::is_signed(types::TypeId const type_id) const {
+bool types::CheckedFunction::is_mutating() const {
 {
-return (((((*this).get_type(type_id)))->is_signed()));
+if ((((((*this).params)).size()) < static_cast<size_t>(1ULL))){
+return (false);
+}
+NonnullRefPtr<types::CheckedVariable> const first_param_variable = ((((((*this).params))[static_cast<i64>(0LL)])).variable);
+return (((((first_param_variable)->name) == Jakt::DeprecatedString("this"sv)) && ((first_param_variable)->is_mutable)));
 }
 }
 
-ErrorOr<JaktInternal::Optional<types::StructId>> types::CheckedProgram::find_struct_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
-{
-return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<types::StructId>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<types::StructId>> {
+types::CheckedFunction::CheckedFunction(DeprecatedString a_name, utility::Span a_name_span, types::CheckedVisibility a_visibility, types::TypeId a_return_type_id, JaktInternal::Optional<utility::Span> a_return_type_span, JaktInternal::DynamicArray<types::CheckedParameter> a_params, NonnullRefPtr<types::FunctionGenerics> a_generics, types::CheckedBlock a_block, bool a_can_throw, parser::FunctionType a_type, parser::FunctionLinkage a_linkage, types::ScopeId a_function_scope_id, JaktInternal::Optional<types::StructId> a_struct_id, bool a_is_instantiated, JaktInternal::Optional<parser::ParsedFunction> a_parsed_function, bool a_is_comptime, bool a_is_virtual, bool a_is_override, JaktInternal::Optional<size_t> a_specialization_index, JaktInternal::Optional<types::ScopeId> a_owner_scope, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Optional<DeprecatedString> a_deprecated_message, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> a_stores_arguments): name(move(a_name)), name_span(move(a_name_span)), visibility(move(a_visibility)), return_type_id(move(a_return_type_id)), return_type_span(move(a_return_type_span)), params(move(a_params)), generics(move(a_generics)), block(move(a_block)), can_throw(move(a_can_throw)), type(move(a_type)), linkage(move(a_linkage)), function_scope_id(move(a_function_scope_id)), struct_id(move(a_struct_id)), is_instantiated(move(a_is_instantiated)), parsed_function(move(a_parsed_function)), is_comptime(move(a_is_comptime)), is_virtual(move(a_is_virtual)), is_override(move(a_is_override)), specialization_index(move(a_specialization_index)), owner_scope(move(a_owner_scope)), external_name(move(a_external_name)), deprecated_message(move(a_deprecated_message)), stores_arguments(move(a_stores_arguments)){}
+ErrorOr<NonnullRefPtr<CheckedFunction>> types::CheckedFunction::__jakt_create(DeprecatedString name, utility::Span name_span, types::CheckedVisibility visibility, types::TypeId return_type_id, JaktInternal::Optional<utility::Span> return_type_span, JaktInternal::DynamicArray<types::CheckedParameter> params, NonnullRefPtr<types::FunctionGenerics> generics, types::CheckedBlock block, bool can_throw, parser::FunctionType type, parser::FunctionLinkage linkage, types::ScopeId function_scope_id, JaktInternal::Optional<types::StructId> struct_id, bool is_instantiated, JaktInternal::Optional<parser::ParsedFunction> parsed_function, bool is_comptime, bool is_virtual, bool is_override, JaktInternal::Optional<size_t> specialization_index, JaktInternal::Optional<types::ScopeId> owner_scope, JaktInternal::Optional<DeprecatedString> external_name, JaktInternal::Optional<DeprecatedString> deprecated_message, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> stores_arguments) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) CheckedFunction (move(name), move(name_span), move(visibility), move(return_type_id), move(return_type_span), move(params), move(generics), move(block), move(can_throw), move(type), move(linkage), move(function_scope_id), move(struct_id), move(is_instantiated), move(parsed_function), move(is_comptime), move(is_virtual), move(is_override), move(specialization_index), move(owner_scope), move(external_name), move(deprecated_message), move(stores_arguments)))); return o; }
+parser::ParsedFunction types::CheckedFunction::to_parsed_function() const {
 {
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::StructId> const maybe_struct = ((((scope)->structs)).get(name));
-if (((maybe_struct).has_value())){
-return ( typename utility::IterationDecision<types::StructId> { typename utility::IterationDecision<types::StructId>::Break((maybe_struct.value())) } );
+if ((!(((((*this).parsed_function)).has_value())))){
+utility::panic(Jakt::DeprecatedString("to_parsed_function() called on a synthetic function"sv));
 }
-return ( typename utility::IterationDecision<types::StructId> { typename utility::IterationDecision<types::StructId>::Continue() } );
+return ((((*this).parsed_function).value()));
 }
 }
-)))))));
+
+bool types::CheckedFunction::is_specialized_for_types(JaktInternal::DynamicArray<types::TypeId> const types) const {
+{
+return (((((*this).generics))->is_specialized_for_types(types)));
 }
 }
 
-ErrorOr<void> types::CheckedProgram::set_loaded_module(DeprecatedString const module_name,types::LoadedModule const loaded_module) {
+ErrorOr<NonnullRefPtr<types::CheckedFunction>> types::CheckedFunction::copy() const {
 {
-TRY((((((*this).loaded_modules)).set(module_name,loaded_module))));
+return (TRY((types::CheckedFunction::__jakt_create(((*this).name),((*this).name_span),((*this).visibility),((*this).return_type_id),((*this).return_type_span),((*this).params),((*this).generics),((*this).block),((*this).can_throw),((*this).type),((*this).linkage),((*this).function_scope_id),((*this).struct_id),((*this).is_instantiated),((*this).parsed_function),((*this).is_comptime),((*this).is_virtual),((*this).is_override),((*this).specialization_index),((*this).owner_scope),((*this).external_name),((*this).deprecated_message),((*this).stores_arguments)))));
 }
-return {};
 }
 
-bool types::CheckedProgram::is_integer(types::TypeId const type_id) const {
+ErrorOr<bool> types::CheckedFunction::signature_matches(NonnullRefPtr<types::CheckedFunction> const other) const {
 {
-NonnullRefPtr<typename types::Type> const type = ((*this).get_type(type_id));
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *type;
-switch(__jakt_match_variant.index()) {
-case 6: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<types::ScopeId> types::CheckedProgram::create_scope(JaktInternal::Optional<types::ScopeId> const parent_scope_id,bool const can_throw,DeprecatedString const debug_name,types::ModuleId const module_id,bool const for_block) {
-{
-if (((parent_scope_id).has_value())){
-if (((((((parent_scope_id.value())).module_id)).id) >= ((((*this).modules)).size()))){
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("create_scope: parent_scope_id.module is invalid! No module with id {}."sv),(((((parent_scope_id.value())).module_id)).id))))))));
-}
-if (((((parent_scope_id.value())).id) >= ((((((((*this).modules))[(((((parent_scope_id.value())).module_id)).id)]))->scopes)).size()))){
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("create_scope: parent_scope_id.id is invalid! Module {} does not have a scope with id {}."sv),(((((parent_scope_id.value())).module_id)).id),(((parent_scope_id.value())).id))))))));
-}
+if ((((((*this).name) != ((other)->name)) || (((*this).can_throw) != ((other)->can_throw))) || (((*this).is_comptime) != ((other)->is_comptime)))){
+return (false);
 }
-JaktInternal::Optional<DeprecatedString> const none_string = JaktInternal::OptionalNone();
-NonnullRefPtr<types::Scope> const scope = TRY((types::Scope::__jakt_create(none_string,none_string,(TRY((Dictionary<DeprecatedString, types::VarId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::StructId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, JaktInternal::DynamicArray<types::FunctionId>>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::EnumId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::TraitId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::ModuleId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::ScopeId>::create_with_entries({})))),parent_scope_id,JaktInternal::OptionalNone(),(TRY((DynamicArray<types::ScopeId>::create_with({})))),can_throw,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),debug_name,(TRY((DynamicArray<types::ScopeId>::create_with({})))),for_block)));
-TRY((((((((((*this).modules))[((module_id).id)]))->scopes)).push(scope))));
-return (types::ScopeId(module_id,(JaktInternal::checked_sub<size_t>(((((((((*this).modules))[((module_id).id)]))->scopes)).size()),static_cast<size_t>(1ULL)))));
+if ((((((*this).params)).size()) != ((((other)->params)).size()))){
+return (false);
 }
+if ((((((((*this).generics))->params)).size()) != ((((((other)->generics))->params)).size()))){
+return (false);
 }
-
-ErrorOr<types::TypeId> types::CheckedProgram::substitute_typevars_in_type(types::TypeId const type_id,types::GenericInferences const generic_inferences,types::ModuleId const module_id) {
+JaktInternal::Set<DeprecatedString> lhs_generic_type_ids = (TRY((Set<DeprecatedString>::create_with_values({}))));
+JaktInternal::Set<DeprecatedString> rhs_generic_type_ids = (TRY((Set<DeprecatedString>::create_with_values({}))));
 {
-types::TypeId result = TRY((((*this).substitute_typevars_in_type_helper(type_id,generic_inferences,module_id))));
+JaktInternal::ArrayIterator<types::FunctionGenericParameter> _magic = ((((((*this).generics))->params)).iterator());
 for (;;){
-types::TypeId const fixed_point = TRY((((*this).substitute_typevars_in_type_helper(type_id,generic_inferences,module_id))));
-if (((fixed_point).equals(result))){
+JaktInternal::Optional<types::FunctionGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
 break;
 }
-else {
-(result = fixed_point);
-}
-
-}
-return (result);
-}
+types::FunctionGenericParameter param = (_magic_value.value());
+{
+types::TypeId const type_id = ((param).type_id());
+TRY((((lhs_generic_type_ids).add(TRY((((type_id).to_string())))))));
 }
 
-NonnullRefPtr<types::Module> types::CheckedProgram::get_module(types::ModuleId const id) const {
-{
-return (((((*this).modules))[((id).id)]));
 }
 }
 
-ErrorOr<JaktInternal::Optional<bool>> types::CheckedProgram::for_each_scope_accessible_unqualified_from_scope_impl(types::ScopeId const scope_id,Function<ErrorOr<typename utility::IterationDecision<bool>>(types::ScopeId, JaktInternal::Optional<DeprecatedString>, bool)> const& callback) const {
-{
-JaktInternal::DynamicArray<types::ScopeId> scopes_to_check = (TRY((DynamicArray<types::ScopeId>::create_with({scope_id}))));
-JaktInternal::Set<DeprecatedString> seen = (TRY((Set<DeprecatedString>::create_with_values({}))));
 {
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((TRY((((*this).get_scope(scope_id)))))->children)).iterator());
+JaktInternal::ArrayIterator<types::FunctionGenericParameter> _magic = ((((((other)->generics))->params)).iterator());
 for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+JaktInternal::Optional<types::FunctionGenericParameter> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::ScopeId child = (_magic_value.value());
+types::FunctionGenericParameter param = (_magic_value.value());
 {
-TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),child))));
+types::TypeId const type_id = ((param).type_id());
+TRY((((rhs_generic_type_ids).add(TRY((((type_id).to_string())))))));
 }
 
 }
 }
 
-while ((!(((scopes_to_check).is_empty())))){
-types::ScopeId const scope_id = (((scopes_to_check).pop()).value());
-TRY((((seen).add(TRY((((scope_id).to_string())))))));
-typename utility::IterationDecision<bool> const res = TRY((callback(scope_id,JaktInternal::OptionalNone(),false)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<JaktInternal::Optional<bool>>>{
-auto&& __jakt_enum_value = JaktInternal::deref_if_ref_pointer(res);
-if (__jakt_enum_value.index() == 0 /* Break */) {
-auto& __jakt_match_value = __jakt_enum_value.template get<typename JaktInternal::RemoveRefPtr<utility::IterationDecision<bool>>::Break>();
-auto& value = __jakt_match_value.value;
-{
-return (static_cast<JaktInternal::Optional<bool>>(value));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::ScopeId> _magic = ((((scope)->aliases)).iterator());
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((*this).params)).size()))});
 for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::ScopeId>> const _magic_value = ((_magic).next());
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-JaktInternal::Tuple<DeprecatedString,types::ScopeId> name__alias__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::ScopeId> const jakt__name__alias__ = name__alias__;
-DeprecatedString const name = ((jakt__name__alias__).template get<0>());
-types::ScopeId const alias = ((jakt__name__alias__).template get<1>());
-
-typename utility::IterationDecision<bool> const res = TRY((callback(alias,name,true)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<JaktInternal::Optional<bool>>>{
-auto&& __jakt_enum_value = JaktInternal::deref_if_ref_pointer(res);
-if (__jakt_enum_value.index() == 0 /* Break */) {
-auto& __jakt_match_value = __jakt_enum_value.template get<typename JaktInternal::RemoveRefPtr<utility::IterationDecision<bool>>::Break>();
-auto& value = __jakt_match_value.value;
+size_t param_index = (_magic_value.value());
 {
-return (static_cast<JaktInternal::Optional<bool>>(value));
-}
-return JaktInternal::ExplicitValue<void>();
+types::CheckedParameter const lhs_param = ((((*this).params))[param_index]);
+types::CheckedParameter const rhs_param = ((((other)->params))[param_index]);
+DeprecatedString const lhs_param_id = TRY((((((((lhs_param).variable))->type_id)).to_string())));
+DeprecatedString const rhs_param_id = TRY((((((((rhs_param).variable))->type_id)).to_string())));
+if (((!(((((((lhs_param).variable))->type_id)).equals(((((rhs_param).variable))->type_id))))) && (!((((lhs_generic_type_ids).contains(lhs_param_id)) && ((rhs_generic_type_ids).contains(rhs_param_id))))))){
+return (false);
 }
-else {
-{
 }
-return JaktInternal::ExplicitValue<void>();
+
 }
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
 }
 
+return (true);
 }
 }
 
+DeprecatedString types::CheckedFunction::name_for_codegen() const {
 {
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->resolution_mixins)).iterator());
-for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (((*this).external_name).value_or_lazy_evaluated([&] { return ((*this).name); }));
 }
-types::ScopeId entry = (_magic_value.value());
-{
-TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),entry))));
-{
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((TRY((((*this).get_scope(entry)))))->children)).iterator());
-for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
 }
-types::ScopeId child = (_magic_value.value());
+
+ErrorOr<void> types::CheckedFunction::add_param(types::CheckedParameter const checked_param) {
 {
-if ((!(((seen).contains(TRY((((child).to_string())))))))){
-TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),child))));
+TRY((((((*this).params)).push(checked_param))));
+TRY((((((((*this).generics))->base_params)).push(checked_param))));
 }
+return {};
 }
 
+ErrorOr<void> types::CheckedFunction::set_params(JaktInternal::DynamicArray<types::CheckedParameter> const checked_params) {
+{
+(((*this).params) = checked_params);
+(((((*this).generics))->base_params) = checked_params);
 }
+return {};
 }
 
+ErrorOr<DeprecatedString> types::ScopeId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ScopeId("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module_id: {}, ", module_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
 }
-
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<DeprecatedString> types::ScopeId::to_string() const {
+{
+return (TRY((__jakt_format(Jakt::DeprecatedString("{}:{}"sv),((((*this).module_id)).id),((*this).id)))));
 }
 }
 
-if (((((scope)->parent)).has_value())){
-TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),(((scope)->parent).value())))));
-{
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((TRY((((*this).get_scope((((scope)->parent).value()))))))->children)).iterator());
-for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::ScopeId child = (_magic_value.value());
+bool types::ScopeId::equals(types::ScopeId const other) const {
 {
-if ((!(((seen).contains(TRY((((child).to_string())))))))){
-TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),child))));
+return (((((((*this).module_id)).id) == ((((other).module_id)).id)) && (((*this).id) == ((other).id))));
 }
 }
 
-}
-}
+types::ScopeId::ScopeId(types::ModuleId a_module_id, size_t a_id) :module_id(move(a_module_id)), id(move(a_id)){}
 
+ErrorOr<DeprecatedString> types::LoadedModule::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("LoadedModule("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module_id: {}, ", module_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("file_id: {}", file_id));
 }
-if (((((scope)->namespace_name)).has_value())){
-continue;
-}
-{
-JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
-for (;;){
-JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::LoadedModule::LoadedModule(types::ModuleId a_module_id, utility::FileId a_file_id) :module_id(move(a_module_id)), file_id(move(a_file_id)){}
+
+ErrorOr<DeprecatedString> types::CheckedVariable::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedVariable("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}, ", type_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_mutable: {}, ", is_mutable));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("definition_span: {}, ", definition_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_span: {}, ", type_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("visibility: {}, ", visibility));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("owner_scope: {}", owner_scope));
 }
-types::ScopeId child = (_magic_value.value());
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<NonnullRefPtr<types::CheckedVariable>> types::CheckedVariable::map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) const {
 {
-if ((!(((seen).contains(TRY((((child).to_string())))))))){
-TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),child))));
+return (TRY((types::CheckedVariable::__jakt_create(((*this).name),TRY((map(((*this).type_id)))),((*this).is_mutable),((*this).definition_span),((*this).type_span),((*this).visibility),((*this).owner_scope)))));
 }
 }
 
+types::CheckedVariable::CheckedVariable(DeprecatedString a_name, types::TypeId a_type_id, bool a_is_mutable, utility::Span a_definition_span, JaktInternal::Optional<utility::Span> a_type_span, types::CheckedVisibility a_visibility, JaktInternal::Optional<types::ScopeId> a_owner_scope): name(move(a_name)), type_id(move(a_type_id)), is_mutable(move(a_is_mutable)), definition_span(move(a_definition_span)), type_span(move(a_type_span)), visibility(move(a_visibility)), owner_scope(move(a_owner_scope)){}
+ErrorOr<NonnullRefPtr<CheckedVariable>> types::CheckedVariable::__jakt_create(DeprecatedString name, types::TypeId type_id, bool is_mutable, utility::Span definition_span, JaktInternal::Optional<utility::Span> type_span, types::CheckedVisibility visibility, JaktInternal::Optional<types::ScopeId> owner_scope) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) CheckedVariable (move(name), move(type_id), move(is_mutable), move(definition_span), move(type_span), move(visibility), move(owner_scope)))); return o; }
+ErrorOr<DeprecatedString> types::CheckedTrait::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedTrait("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("methods: {}, ", methods));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_parameters: {}, ", generic_parameters));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scope_id: {}", scope_id));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::CheckedTrait::CheckedTrait(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> a_methods, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, types::ScopeId a_scope_id): name(move(a_name)), name_span(move(a_name_span)), methods(move(a_methods)), generic_parameters(move(a_generic_parameters)), scope_id(move(a_scope_id)){}
+ErrorOr<NonnullRefPtr<CheckedTrait>> types::CheckedTrait::__jakt_create(DeprecatedString name, utility::Span name_span, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> methods, JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters, types::ScopeId scope_id) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) CheckedTrait (move(name), move(name_span), move(methods), move(generic_parameters), move(scope_id)))); return o; }
+ErrorOr<DeprecatedString> types::Value::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Value("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("impl: {}, ", impl));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
 }
-
-}
-types::ModuleId const module_id = ((scope_id).module_id);
-types::ScopeId const search_scope_id = types::ScopeId(module_id,static_cast<size_t>(0ULL));
-NonnullRefPtr<types::Scope> const search_scope = TRY((((*this).get_scope(search_scope_id))));
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<types::Value> types::Value::copy() const {
 {
-JaktInternal::DictionaryIterator<DeprecatedString,types::ModuleId> _magic = ((((search_scope)->imports)).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::ModuleId>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-JaktInternal::Tuple<DeprecatedString,types::ModuleId> name__module__ = (_magic_value.value());
-{
-JaktInternal::Tuple<DeprecatedString,types::ModuleId> const jakt__name__module__ = name__module__;
-DeprecatedString const name = ((jakt__name__module__).template get<0>());
-types::ModuleId const module = ((jakt__name__module__).template get<1>());
-
-types::ScopeId const import_scope_id = types::ScopeId(module,static_cast<size_t>(0ULL));
-typename utility::IterationDecision<bool> const res = TRY((callback(import_scope_id,name,false)));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<JaktInternal::Optional<bool>>>{
-auto&& __jakt_enum_value = JaktInternal::deref_if_ref_pointer(res);
-if (__jakt_enum_value.index() == 0 /* Break */) {
-auto& __jakt_match_value = __jakt_enum_value.template get<typename JaktInternal::RemoveRefPtr<utility::IterationDecision<bool>>::Break>();
-auto& value = __jakt_match_value.value;
-{
-return (static_cast<JaktInternal::Optional<bool>>(value));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else {
-{
-}
-return JaktInternal::ExplicitValue<void>();
-}
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
-}
-
-}
-}
-
-return (JaktInternal::OptionalNone());
-}
-}
-
-ErrorOr<bool> types::CheckedProgram::is_scope_directly_accessible_from(types::ScopeId const check_scope_id,types::ScopeId const scope_id) const {
-{
-return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<bool>(scope_id,(([check_scope_id](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<bool>> {
-{
-if (((check_scope_id).equals(scope_id))){
-return ( typename utility::IterationDecision<bool> { typename utility::IterationDecision<bool>::Break(true) } );
-}
-return ( typename utility::IterationDecision<bool> { typename utility::IterationDecision<bool>::Continue() } );
-}
-}
-)))))).value_or_lazy_evaluated([&] { return false; }));
+return (types::Value(TRY((((((*this).impl))->copy()))),((*this).span)));
 }
 }
 
-ErrorOr<types::TypeId> types::CheckedProgram::substitute_typevars_in_type_helper(types::TypeId const type_id,types::GenericInferences const generic_inferences,types::ModuleId const module_id) {
+DeprecatedString types::Value::type_name() const {
 {
-NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(type_id));
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<types::TypeId>>{
-auto&& __jakt_match_variant = *type_;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, DeprecatedString>{
+auto&& __jakt_match_variant = *((*this).impl);
 switch(__jakt_match_variant.index()) {
-case 18: {
-{
-JaktInternal::Optional<DeprecatedString> const replacment_type_id_string = ((generic_inferences).get(TRY((((type_id).to_string())))));
-if (((replacment_type_id_string).has_value())){
-return (TRY((types::TypeId::from_string(((replacment_type_id_string).value())))));
-}
-}
-return JaktInternal::ExplicitValue<void>();
+case 0: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("void"sv));
 };/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-{
-JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((new_args).ensure_capacity(((args).size())))));
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::TypeId arg = (_magic_value.value());
-{
-TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(arg,generic_inferences,module_id))))))));
-}
-
-}
-}
-
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericTraitInstance>(id,new_args))),module_id)))));
-}
-return JaktInternal::ExplicitValue<void>();
+case 1: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("bool"sv));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u8"sv));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u16"sv));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u32"sv));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u64"sv));
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i18"sv));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i16"sv));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i32"sv));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i64"sv));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("f32"sv));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("f64"sv));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("usize"sv));
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("String"sv));
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("StringView"sv));
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("c_char"sv));
+};/*case end*/
+case 16: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("c_int"sv));
+};/*case end*/
+case 17: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("struct <T>"sv));
+};/*case end*/
+case 18: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("class <T>"sv));
 };/*case end*/
 case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-{
-JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((new_args).ensure_capacity(((args).size())))));
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::TypeId arg = (_magic_value.value());
-{
-TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(arg,generic_inferences,module_id))))))));
-}
-
-}
-}
-
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(id,new_args))),module_id)))));
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("enum <T>"sv));
 };/*case end*/
 case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-{
-JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((new_args).ensure_capacity(((args).size())))));
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::TypeId arg = (_magic_value.value());
-{
-TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(arg,generic_inferences,module_id))))))));
-}
-
-}
-}
-
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericEnumInstance>(id,new_args))),module_id)))));
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Array"sv));
+};/*case end*/
+case 21: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Dictionary"sv));
+};/*case end*/
+case 22: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Set"sv));
 };/*case end*/
 case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& struct_id = __jakt_match_value.value;
-{
-types::CheckedStruct const struct_ = ((*this).get_struct(struct_id));
-if ((!(((((struct_).generic_parameters)).is_empty())))){
-JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((new_args).ensure_capacity(((((struct_).generic_parameters)).size())))));
-{
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("raw <T>"sv));
+};/*case end*/
+case 24: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Some"sv));
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("None"sv));
+};/*case end*/
+case 26: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Tuple"sv));
+};/*case end*/
+case 27: {
+return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Function"sv));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-types::CheckedGenericParameter arg = (_magic_value.value());
-{
-TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(((arg).type_id),generic_inferences,module_id))))))));
 }
 
-}
-}
+types::Value::Value(NonnullRefPtr<typename types::ValueImpl> a_impl, utility::Span a_span) :impl(move(a_impl)), span(move(a_span)){}
 
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(struct_id,new_args))),module_id)))));
-}
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& enum_id = __jakt_match_value.value;
-{
-types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
-if ((!(((((enum_).generic_parameters)).is_empty())))){
-JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((new_args).ensure_capacity(((((enum_).generic_parameters)).size())))));
+ErrorOr<types::Value> types::Value::cast(types::Value const expected,utility::Span const span) const {
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((enum_).generic_parameters)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((*this).impl);
+switch(__jakt_match_variant.index()) {
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
+u8 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 3: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>((value)))))),span));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((infallible_integer_cast<u32>((value)))))),span));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((infallible_integer_cast<u64>((value)))))),span));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
+u16 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 4: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((infallible_integer_cast<u32>((value)))))),span));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((infallible_integer_cast<u64>((value)))))),span));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
+u32 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((infallible_integer_cast<u64>((value)))))),span));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
+u64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
+i8 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 7: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>((value)))))),span));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((infallible_integer_cast<i32>((value)))))),span));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((infallible_integer_cast<i64>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
+i16 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 8: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((infallible_integer_cast<i32>((value)))))),span));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((infallible_integer_cast<i64>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
+i32 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 9: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((infallible_integer_cast<i64>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
+i64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 12: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
+size_t const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 5: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((infallible_integer_cast<u64>((value)))))),span));
+};/*case end*/
+case 16: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((infallible_integer_cast<int>((value)))))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+case 24: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
+auto&& __jakt_match_variant = *((expected).impl);
+switch(__jakt_match_variant.index()) {
+case 24: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(*this))),span));
+};/*case end*/
+case 25: {
+return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(*this))),span));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(*this);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
-types::CheckedGenericParameter arg = (_magic_value.value());
-{
-TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(((arg).type_id),generic_inferences,module_id))))))));
 }
 
+ErrorOr<DeprecatedString> types::CheckedProgram::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedProgram("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("compiler: {}, ", *compiler));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("modules: {}, ", modules));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("loaded_modules: {}", loaded_modules));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<types::TypeId> types::CheckedProgram::substitute_typevars_in_type(types::TypeId const type_id,types::GenericInferences const generic_inferences,types::ModuleId const module_id) {
+{
+types::TypeId result = TRY((((*this).substitute_typevars_in_type_helper(type_id,generic_inferences,module_id))));
+for (;;){
+types::TypeId const fixed_point = TRY((((*this).substitute_typevars_in_type_helper(type_id,generic_inferences,module_id))));
+if (((fixed_point).equals(result))){
+break;
+}
+else {
+(result = fixed_point);
 }
 
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericEnumInstance>(enum_id,new_args))),module_id)))));
 }
+return (result);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
-types::TypeId const& rawptr_type_id = __jakt_match_value.value;
-{
-NonnullRefPtr<typename types::Type> const rawptr_type = TRY((types::Type::template __jakt_create<typename types::Type::RawPtr>(TRY((((*this).substitute_typevars_in_type(rawptr_type_id,generic_inferences,module_id)))))));
-return (TRY((((*this).find_or_add_type_id(rawptr_type,module_id)))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
-types::TypeId const& ref_type_id = __jakt_match_value.value;
+
+ErrorOr<NonnullRefPtr<types::Scope>> types::CheckedProgram::get_scope(types::ScopeId const id) const {
 {
-NonnullRefPtr<typename types::Type> const ref_type = TRY((types::Type::template __jakt_create<typename types::Type::Reference>(TRY((((*this).substitute_typevars_in_type(ref_type_id,generic_inferences,module_id)))))));
-return (TRY((((*this).find_or_add_type_id(ref_type,module_id)))));
+size_t const max_scope = (JaktInternal::checked_sub<size_t>(((((((((*this).modules))[((((id).module_id)).id)]))->scopes)).size()),static_cast<size_t>(1ULL)));
+if ((((id).id) > max_scope)){
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("scope_id {} does not exist in module"sv),id)))))));
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
-types::TypeId const& ref_type_id = __jakt_match_value.value;
-{
-NonnullRefPtr<typename types::Type> const ref_type = TRY((types::Type::template __jakt_create<typename types::Type::MutableReference>(TRY((((*this).substitute_typevars_in_type(ref_type_id,generic_inferences,module_id)))))));
-return (TRY((((*this).find_or_add_type_id(ref_type,module_id)))));
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
-bool const& can_throw = __jakt_match_value.can_throw;
-types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
-types::FunctionId const& pseudo_function_id = __jakt_match_value.pseudo_function_id;
-{
-JaktInternal::DynamicArray<types::TypeId> new_params = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-TRY((((new_params).ensure_capacity(((params).size())))));
-bool is_different = false;
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((params).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::TypeId param = (_magic_value.value());
-{
-types::TypeId const new_param = TRY((((*this).substitute_typevars_in_type(param,generic_inferences,module_id))));
-(is_different = (is_different || (!(((new_param).equals(param))))));
-TRY((((new_params).push(new_param))));
-}
-
+return (((((((((*this).modules))[((((id).module_id)).id)]))->scopes))[((id).id)]));
 }
 }
 
-types::TypeId const return_type_substitute = TRY((((*this).substitute_typevars_in_type(return_type_id,generic_inferences,module_id))));
-(is_different = (is_different || (!(((return_type_substitute).equals(return_type_id))))));
-if ((!(is_different))){
-return (type_id);
-}
-NonnullRefPtr<types::CheckedFunction> const previous_function = ((*this).get_function(pseudo_function_id));
-JaktInternal::DynamicArray<types::CheckedParameter> replacement_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((previous_function)->params)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
+ErrorOr<types::StructId> types::CheckedProgram::find_struct_in_prelude(DeprecatedString const name) const {
 {
-types::CheckedParameter const param = ((((previous_function)->params))[i]);
-types::CheckedParameter const new_param = types::CheckedParameter(((param).requires_label),TRY((types::CheckedVariable::__jakt_create(((((param).variable))->name),((new_params)[i]),((((param).variable))->is_mutable),((((param).variable))->definition_span),((((param).variable))->type_span),((((param).variable))->visibility),JaktInternal::OptionalNone()))),((param).default_value));
-TRY((((replacement_params).push(new_param))));
+types::ScopeId const scope_id = ((*this).prelude_scope_id());
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,name))));
+if (((struct_id).has_value())){
+return (((struct_id).value()));
 }
-
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("internal error: {} builtin definition not found"sv),name)))))));
 }
 }
 
-NonnullRefPtr<types::CheckedFunction> const new_function = TRY((types::CheckedFunction::__jakt_create(((previous_function)->name),((previous_function)->name_span),((previous_function)->visibility),return_type_substitute,((previous_function)->return_type_span),replacement_params,((previous_function)->generics),((previous_function)->block),can_throw,((previous_function)->type),((previous_function)->linkage),((previous_function)->function_scope_id),((previous_function)->struct_id),((previous_function)->is_instantiated),((previous_function)->parsed_function),((previous_function)->is_comptime),((previous_function)->is_virtual),((previous_function)->is_override),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
-types::FunctionId const new_function_id = TRY((((((((*this).modules))[((module_id).id)]))->add_function(new_function))));
-return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Function>(new_params,can_throw,return_type_substitute,new_function_id))),module_id)))));
-}
-return JaktInternal::ExplicitValue<void>();
+bool types::CheckedProgram::is_floating(types::TypeId const type_id) const {
+{
+NonnullRefPtr<typename types::Type> const type = ((*this).get_type(type_id));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *type;
+switch(__jakt_match_variant.index()) {
+case 10: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 default: {
-{
-return (type_id);
-}
-return JaktInternal::ExplicitValue<void>();
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
 }/*switch end*/
 }()
-));
-return (type_id);
-}
-}
-
-bool types::CheckedProgram::is_string(types::TypeId const type_id) const {
-{
-return (((((*this).get_type(type_id)))->index() == 13 /* JaktString */));
-}
-}
-
-types::ScopeId types::CheckedProgram::prelude_scope_id() const {
-{
-return (types::ScopeId(types::ModuleId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL)));
-}
-}
-
-types::CheckedProgram::CheckedProgram(NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> a_modules, JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> a_loaded_modules): compiler(move(a_compiler)), modules(move(a_modules)), loaded_modules(move(a_loaded_modules)){}
-ErrorOr<NonnullRefPtr<CheckedProgram>> types::CheckedProgram::__jakt_create(NonnullRefPtr<compiler::Compiler> compiler, JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> modules, JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> loaded_modules) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) CheckedProgram (move(compiler), move(modules), move(loaded_modules)))); return o; }
-NonnullRefPtr<types::CheckedFunction> types::CheckedProgram::get_function(types::FunctionId const id) const {
-{
-return (((((((((*this).modules))[((((id).module)).id)]))->functions))[((id).id)]));
+)));
 }
 }
 
-ErrorOr<JaktInternal::Optional<types::Value>> types::CheckedProgram::find_comptime_binding_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
+ErrorOr<JaktInternal::Optional<types::StructId>> types::CheckedProgram::find_struct_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
 {
-return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<types::Value>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<types::Value>> {
+return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<types::StructId>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<types::StructId>> {
 {
 NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::Value> const maybe_binding = ((((scope)->comptime_bindings)).get(name));
-if (((maybe_binding).has_value())){
-return ( typename utility::IterationDecision<types::Value> { typename utility::IterationDecision<types::Value>::Break((maybe_binding.value())) } );
+JaktInternal::Optional<types::StructId> const maybe_struct = ((((scope)->structs)).get(name));
+if (((maybe_struct).has_value())){
+return ( typename utility::IterationDecision<types::StructId> { typename utility::IterationDecision<types::StructId>::Break((maybe_struct.value())) } );
 }
-return ( typename utility::IterationDecision<types::Value> { typename utility::IterationDecision<types::Value>::Continue() } );
+return ( typename utility::IterationDecision<types::StructId> { typename utility::IterationDecision<types::StructId>::Continue() } );
 }
 }
 )))))));
 }
 }
 
-i64 types::CheckedProgram::get_bits(types::TypeId const type_id) const {
-{
-return (((((*this).get_type(type_id)))->get_bits()));
-}
-}
-
-NonnullRefPtr<typename types::Type> types::CheckedProgram::get_type(types::TypeId const id) const {
-{
-return (((((((((*this).modules))[((((id).module)).id)]))->types))[((id).id)]));
-}
-}
-
-ErrorOr<types::TypeId> types::CheckedProgram::find_or_add_type_id(NonnullRefPtr<typename types::Type> const type,types::ModuleId const module_id) {
-{
-{
-JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> _magic = ((((*this).modules)).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<types::Module>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-NonnullRefPtr<types::Module> module = (_magic_value.value());
-{
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((module)->types)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t id = (_magic_value.value());
-{
-if (((((((module)->types))[id]))->equals(type))){
-return (types::TypeId(((module)->id),id));
-}
-}
-
-}
-}
-
-}
-
-}
-}
-
-TRY((((((((((*this).modules))[((module_id).id)]))->types)).push(type))));
-return (types::TypeId(module_id,(JaktInternal::checked_sub<size_t>(((((((((*this).modules))[((module_id).id)]))->types)).size()),static_cast<size_t>(1ULL)))));
-}
-}
-
-ErrorOr<types::StructId> types::CheckedProgram::find_struct_in_prelude(DeprecatedString const name) const {
-{
-types::ScopeId const scope_id = ((*this).prelude_scope_id());
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(scope_id,name))));
-if (((struct_id).has_value())){
-return (((struct_id).value()));
-}
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("internal error: {} builtin definition not found"sv),name)))))));
-}
-}
-
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>>> types::CheckedProgram::find_namespace_in_scope(types::ScopeId const scope_id,DeprecatedString const name,bool const treat_aliases_as_imports) const {
-{
-return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<JaktInternal::Tuple<types::ScopeId,bool>>(scope_id,(([name, treat_aliases_as_imports, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>>> {
+ErrorOr<void> types::CheckedProgram::set_loaded_module(DeprecatedString const module_name,types::LoadedModule const loaded_module) {
 {
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<DeprecatedString> const effective_name = name_override.value_or_lazy_evaluated_optional([&] { return ((scope)->namespace_name); });
-bool const is_import = (((name_override).has_value()) && (!(is_alias)));
-if ((((effective_name).has_value()) && ((effective_name.value()) == name))){
-return ( typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>> { typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>>::Break((Tuple{scope_id, (is_import || (is_alias && treat_aliases_as_imports))})) } );
-}
-return ( typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>> { typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>>::Continue() } );
-}
-}
-)))))));
+TRY((((((*this).loaded_modules)).set(module_name,loaded_module))));
 }
+return {};
 }
 
-types::CheckedEnum types::CheckedProgram::get_enum(types::EnumId const id) const {
+bool types::CheckedProgram::is_integer(types::TypeId const type_id) const {
 {
-return (((((((((*this).modules))[((((id).module)).id)]))->enums))[((id).id)]));
+NonnullRefPtr<typename types::Type> const type = ((*this).get_type(type_id));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *type;
+switch(__jakt_match_variant.index()) {
+case 6: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
-ErrorOr<JaktInternal::Optional<types::TraitId>> types::CheckedProgram::find_trait_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
-{
-return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<types::TraitId>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<types::TraitId>> {
+ErrorOr<types::ScopeId> types::CheckedProgram::create_scope(JaktInternal::Optional<types::ScopeId> const parent_scope_id,bool const can_throw,DeprecatedString const debug_name,types::ModuleId const module_id,bool const for_block) {
 {
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::TraitId> const maybe_trait = ((((scope)->traits)).get(name));
-if (((maybe_trait).has_value())){
-return ( typename utility::IterationDecision<types::TraitId> { typename utility::IterationDecision<types::TraitId>::Break((maybe_trait.value())) } );
+if (((parent_scope_id).has_value())){
+if (((((((parent_scope_id.value())).module_id)).id) >= ((((*this).modules)).size()))){
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("create_scope: parent_scope_id.module is invalid! No module with id {}."sv),(((((parent_scope_id.value())).module_id)).id))))))));
 }
-return ( typename utility::IterationDecision<types::TraitId> { typename utility::IterationDecision<types::TraitId>::Continue() } );
+if (((((parent_scope_id.value())).id) >= ((((((((*this).modules))[(((((parent_scope_id.value())).module_id)).id)]))->scopes)).size()))){
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("create_scope: parent_scope_id.id is invalid! Module {} does not have a scope with id {}."sv),(((((parent_scope_id.value())).module_id)).id),(((parent_scope_id.value())).id))))))));
 }
 }
-)))))));
+JaktInternal::Optional<DeprecatedString> const none_string = JaktInternal::OptionalNone();
+NonnullRefPtr<types::Scope> const scope = TRY((types::Scope::__jakt_create(none_string,none_string,(TRY((Dictionary<DeprecatedString, types::VarId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::Value>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::StructId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, JaktInternal::DynamicArray<types::FunctionId>>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::EnumId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::TypeId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::TraitId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::ModuleId>::create_with_entries({})))),(TRY((Dictionary<DeprecatedString, types::ScopeId>::create_with_entries({})))),parent_scope_id,JaktInternal::OptionalNone(),(TRY((DynamicArray<types::ScopeId>::create_with({})))),can_throw,JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),(TRY((DynamicArray<parser::IncludeAction>::create_with({})))),debug_name,(TRY((DynamicArray<types::ScopeId>::create_with({})))),for_block)));
+TRY((((((((((*this).modules))[((module_id).id)]))->scopes)).push(scope))));
+return (types::ScopeId(module_id,(JaktInternal::checked_sub<size_t>(((((((((*this).modules))[((module_id).id)]))->scopes)).size()),static_cast<size_t>(1ULL)))));
 }
 }
 
-NonnullRefPtr<types::CheckedTrait> types::CheckedProgram::get_trait(types::TraitId const id) const {
+NonnullRefPtr<types::Module> types::CheckedProgram::get_module(types::ModuleId const id) const {
 {
-return (((((((((*this).modules))[((((id).module)).id)]))->traits))[((id).id)]));
+return (((((*this).modules))[((id).id)]));
 }
 }
 
@@ -1365,877 +1298,942 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>>> types::CheckedProgram::find_functions_with_name_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
+ErrorOr<JaktInternal::Optional<bool>> types::CheckedProgram::for_each_scope_accessible_unqualified_from_scope_impl(types::ScopeId const scope_id,Function<ErrorOr<typename utility::IterationDecision<bool>>(types::ScopeId, JaktInternal::Optional<DeprecatedString>, bool)> const& callback) const {
 {
-return (((TRY((((*this).find_scoped_functions_with_name_in_scope(parent_scope_id,function_name))))).map([](auto& _value) { return _value.template get<0>(); })));
-}
-}
-
-ErrorOr<JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>>> types::CheckedProgram::find_var_in_scope(types::ScopeId const scope_id,DeprecatedString const var) const {
+JaktInternal::DynamicArray<types::ScopeId> scopes_to_check = (TRY((DynamicArray<types::ScopeId>::create_with({scope_id}))));
+JaktInternal::Set<DeprecatedString> seen = (TRY((Set<DeprecatedString>::create_with_values({}))));
 {
-return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<NonnullRefPtr<types::CheckedVariable>>(scope_id,(([var, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>>> {
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((TRY((((*this).get_scope(scope_id)))))->children)).iterator());
+for (;;){
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::ScopeId child = (_magic_value.value());
 {
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::VarId> const maybe_var = ((((scope)->vars)).get(var));
-if (((maybe_var).has_value())){
-return ( typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>> { typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>>::Break(((*this).get_variable((maybe_var.value())))) } );
+TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),child))));
 }
-return ( typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>> { typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>>::Continue() } );
+
 }
 }
-)))))));
+
+while ((!(((scopes_to_check).is_empty())))){
+types::ScopeId const scope_id = (((scopes_to_check).pop()).value());
+TRY((((seen).add(TRY((((scope_id).to_string())))))));
+typename utility::IterationDecision<bool> const res = TRY((callback(scope_id,JaktInternal::OptionalNone(),false)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<JaktInternal::Optional<bool>>>{
+auto&& __jakt_enum_value = JaktInternal::deref_if_ref_pointer(res);
+if (__jakt_enum_value.index() == 0 /* Break */) {
+auto& __jakt_match_value = __jakt_enum_value.template get<typename JaktInternal::RemoveRefPtr<utility::IterationDecision<bool>>::Break>();
+auto& value = __jakt_match_value.value;
+{
+return (static_cast<JaktInternal::Optional<bool>>(value));
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else {
+{
+}
+return JaktInternal::ExplicitValue<void>();
 }
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::ScopeId> _magic = ((((scope)->aliases)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::ScopeId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+JaktInternal::Tuple<DeprecatedString,types::ScopeId> name__alias__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::ScopeId> const jakt__name__alias__ = name__alias__;
+DeprecatedString const name = ((jakt__name__alias__).template get<0>());
+types::ScopeId const alias = ((jakt__name__alias__).template get<1>());
 
-ErrorOr<JaktInternal::Optional<types::FunctionId>> types::CheckedProgram::find_function_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
+typename utility::IterationDecision<bool> const res = TRY((callback(alias,name,true)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<JaktInternal::Optional<bool>>>{
+auto&& __jakt_enum_value = JaktInternal::deref_if_ref_pointer(res);
+if (__jakt_enum_value.index() == 0 /* Break */) {
+auto& __jakt_match_value = __jakt_enum_value.template get<typename JaktInternal::RemoveRefPtr<utility::IterationDecision<bool>>::Break>();
+auto& value = __jakt_match_value.value;
 {
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const results = TRY((((*this).find_functions_with_name_in_scope(parent_scope_id,function_name))));
-if ((!(((results).has_value())))){
-return (JaktInternal::OptionalNone());
+return (static_cast<JaktInternal::Optional<bool>>(value));
 }
-JaktInternal::DynamicArray<types::FunctionId> const functions = ((results).value());
-if ((((functions).size()) != static_cast<size_t>(1ULL))){
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("internal error: found multiple (or no) functions with name '{}'"sv),function_name)))))));
+return JaktInternal::ExplicitValue<void>();
 }
-return (((functions)[static_cast<i64>(0LL)]));
+else {
+{
 }
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
 }
 
-types::CheckedStruct types::CheckedProgram::get_struct(types::StructId const id) const {
-{
-return (((((((((*this).modules))[((((id).module)).id)]))->structures))[((id).id)]));
 }
 }
 
-ErrorOr<JaktInternal::Optional<types::StructId>> types::CheckedProgram::check_and_extract_weak_ptr(types::StructId const struct_id,JaktInternal::DynamicArray<types::TypeId> const args) const {
 {
-types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
-if (((struct_id).equals(weak_ptr_struct_id))){
-if ((((args).size()) != static_cast<size_t>(1ULL))){
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("Internal error: Generic type is WeakPtr but there are not exactly 1 type parameter. There are {} parameters."sv),((args).size()))))))));
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->resolution_mixins)).iterator());
+for (;;){
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-types::TypeId const inner_type_id = ((args)[static_cast<i64>(0LL)]);
-NonnullRefPtr<typename types::Type> const inner_type = ((*this).get_type(inner_type_id));
-if (((inner_type)->index() == 23 /* Struct */)){
-types::StructId const inner_struct_id = ((inner_type)->get<types::Type::Struct>()).value;
-return (inner_struct_id);
+types::ScopeId entry = (_magic_value.value());
+{
+TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),entry))));
+{
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((TRY((((*this).get_scope(entry)))))->children)).iterator());
+for (;;){
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Internal error: Inner type of WeakPtr is not a struct. It is {}."sv),inner_type))));
+types::ScopeId child = (_magic_value.value());
+{
+if ((!(((seen).contains(TRY((((child).to_string())))))))){
+TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),child))));
 }
-else {
-return (JaktInternal::OptionalNone());
 }
 
 }
 }
 
-ErrorOr<JaktInternal::Optional<types::EnumId>> types::CheckedProgram::find_enum_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
-{
-return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<types::EnumId>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<types::EnumId>> {
+}
+
+}
+}
+
+if (((((scope)->parent)).has_value())){
+TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),(((scope)->parent).value())))));
 {
-NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
-JaktInternal::Optional<types::EnumId> const maybe_enum = ((((scope)->enums)).get(name));
-if (((maybe_enum).has_value())){
-return ( typename utility::IterationDecision<types::EnumId> { typename utility::IterationDecision<types::EnumId>::Break((maybe_enum.value())) } );
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((TRY((((*this).get_scope((((scope)->parent).value()))))))->children)).iterator());
+for (;;){
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-return ( typename utility::IterationDecision<types::EnumId> { typename utility::IterationDecision<types::EnumId>::Continue() } );
+types::ScopeId child = (_magic_value.value());
+{
+if ((!(((seen).contains(TRY((((child).to_string())))))))){
+TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),child))));
 }
 }
-)))))));
+
 }
 }
 
-JaktInternal::Optional<types::LoadedModule> types::CheckedProgram::get_loaded_module(DeprecatedString const module_name) const {
+}
+if (((((scope)->namespace_name)).has_value())){
+continue;
+}
 {
-return (((((*this).loaded_modules)).get(module_name)));
+JaktInternal::ArrayIterator<types::ScopeId> _magic = ((((scope)->children)).iterator());
+for (;;){
+JaktInternal::Optional<types::ScopeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::ScopeId child = (_magic_value.value());
+{
+if ((!(((seen).contains(TRY((((child).to_string())))))))){
+TRY((((scopes_to_check).insert(static_cast<size_t>(0ULL),child))));
 }
 }
 
-bool types::CheckedProgram::is_numeric(types::TypeId const type_id) const {
-{
-return ((((*this).is_integer(type_id)) || ((*this).is_floating(type_id))));
 }
 }
 
-NonnullRefPtr<types::CheckedVariable> types::CheckedProgram::get_variable(types::VarId const id) const {
+}
+types::ModuleId const module_id = ((scope_id).module_id);
+types::ScopeId const search_scope_id = types::ScopeId(module_id,static_cast<size_t>(0ULL));
+NonnullRefPtr<types::Scope> const search_scope = TRY((((*this).get_scope(search_scope_id))));
+{
+JaktInternal::DictionaryIterator<DeprecatedString,types::ModuleId> _magic = ((((search_scope)->imports)).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<DeprecatedString,types::ModuleId>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+JaktInternal::Tuple<DeprecatedString,types::ModuleId> name__module__ = (_magic_value.value());
+{
+JaktInternal::Tuple<DeprecatedString,types::ModuleId> const jakt__name__module__ = name__module__;
+DeprecatedString const name = ((jakt__name__module__).template get<0>());
+types::ModuleId const module = ((jakt__name__module__).template get<1>());
+
+types::ScopeId const import_scope_id = types::ScopeId(module,static_cast<size_t>(0ULL));
+typename utility::IterationDecision<bool> const res = TRY((callback(import_scope_id,name,false)));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<JaktInternal::Optional<bool>>>{
+auto&& __jakt_enum_value = JaktInternal::deref_if_ref_pointer(res);
+if (__jakt_enum_value.index() == 0 /* Break */) {
+auto& __jakt_match_value = __jakt_enum_value.template get<typename JaktInternal::RemoveRefPtr<utility::IterationDecision<bool>>::Break>();
+auto& value = __jakt_match_value.value;
+{
+return (static_cast<JaktInternal::Optional<bool>>(value));
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else {
 {
-return (((((((((*this).modules))[((((id).module)).id)]))->variables))[((id).id)]));
 }
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
 }
 
-ErrorOr<types::StructOrEnumId> types::CheckedProgram::find_reflected_primitive(DeprecatedString const primitive) const {
+}
+}
+
+return (JaktInternal::OptionalNone());
+}
+}
+
+ErrorOr<bool> types::CheckedProgram::is_scope_directly_accessible_from(types::ScopeId const check_scope_id,types::ScopeId const scope_id) const {
 {
-types::ScopeId const scope_id = ((*this).prelude_scope_id());
-JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const maybe_namespace = TRY((((*this).find_namespace_in_scope(scope_id,Jakt::DeprecatedString("Reflect"sv),false))));
-if ((!(((maybe_namespace).has_value())))){
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("internal error: builtin namespace 'Reflect' not found"sv))))))));
+return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<bool>(scope_id,(([check_scope_id](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<bool>> {
+{
+if (((check_scope_id).equals(scope_id))){
+return ( typename utility::IterationDecision<bool> { typename utility::IterationDecision<bool>::Break(true) } );
 }
-types::ScopeId const reflect_namespace_scope_id = (((maybe_namespace.value())).template get<0>());
-JaktInternal::Optional<types::EnumId> const enum_id = TRY((((*this).find_enum_in_scope(reflect_namespace_scope_id,primitive))));
-if (((enum_id).has_value())){
-return ( types::StructOrEnumId { typename types::StructOrEnumId::Enum((enum_id.value())) } );
+return ( typename utility::IterationDecision<bool> { typename utility::IterationDecision<bool>::Continue() } );
 }
-JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(reflect_namespace_scope_id,primitive))));
-if (((struct_id).has_value())){
-return ( types::StructOrEnumId { typename types::StructOrEnumId::Struct((struct_id.value())) } );
 }
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("internal error: definition for reflect builtin '{}' not found"sv),primitive)))))));
+)))))).value_or_lazy_evaluated([&] { return false; }));
 }
 }
 
-ErrorOr<NonnullRefPtr<types::Scope>> types::CheckedProgram::get_scope(types::ScopeId const id) const {
+bool types::CheckedProgram::is_string(types::TypeId const type_id) const {
 {
-size_t const max_scope = (JaktInternal::checked_sub<size_t>(((((((((*this).modules))[((((id).module_id)).id)]))->scopes)).size()),static_cast<size_t>(1ULL)));
-if ((((id).id) > max_scope)){
-TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("scope_id {} does not exist in module"sv),id)))))));
+return (((((*this).get_type(type_id)))->index() == 13 /* JaktString */));
 }
-return (((((((((*this).modules))[((((id).module_id)).id)]))->scopes))[((id).id)]));
+}
+
+NonnullRefPtr<types::CheckedTrait> types::CheckedProgram::get_trait(types::TraitId const id) const {
+{
+return (((((((((*this).modules))[((((id).module)).id)]))->traits))[((id).id)]));
 }
 }
 
-ErrorOr<DeprecatedString> types::Value::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Value("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("impl: {}, ", impl));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
+types::ScopeId types::CheckedProgram::prelude_scope_id() const {
+{
+return (types::ScopeId(types::ModuleId(static_cast<size_t>(0ULL)),static_cast<size_t>(0ULL)));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<types::Value> types::Value::copy() const {
+}
+
+NonnullRefPtr<types::CheckedVariable> types::CheckedProgram::get_variable(types::VarId const id) const {
 {
-return (types::Value(TRY((((((*this).impl))->copy()))),((*this).span)));
+return (((((((((*this).modules))[((((id).module)).id)]))->variables))[((id).id)]));
 }
 }
 
-types::Value::Value(NonnullRefPtr<typename types::ValueImpl> a_impl, utility::Span a_span) :impl(move(a_impl)), span(move(a_span)){}
+types::CheckedProgram::CheckedProgram(NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> a_modules, JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> a_loaded_modules): compiler(move(a_compiler)), modules(move(a_modules)), loaded_modules(move(a_loaded_modules)){}
+ErrorOr<NonnullRefPtr<CheckedProgram>> types::CheckedProgram::__jakt_create(NonnullRefPtr<compiler::Compiler> compiler, JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> modules, JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> loaded_modules) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) CheckedProgram (move(compiler), move(modules), move(loaded_modules)))); return o; }
+NonnullRefPtr<types::CheckedFunction> types::CheckedProgram::get_function(types::FunctionId const id) const {
+{
+return (((((((((*this).modules))[((((id).module)).id)]))->functions))[((id).id)]));
+}
+}
 
-ErrorOr<types::Value> types::Value::cast(types::Value const expected,utility::Span const span) const {
+ErrorOr<JaktInternal::Optional<types::Value>> types::CheckedProgram::find_comptime_binding_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((*this).impl);
-switch(__jakt_match_variant.index()) {
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U8>();
-u8 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 3: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U16>((infallible_integer_cast<u16>((value)))))),span));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((infallible_integer_cast<u32>((value)))))),span));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((infallible_integer_cast<u64>((value)))))),span));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U16>();
-u16 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 4: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U32>((infallible_integer_cast<u32>((value)))))),span));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((infallible_integer_cast<u64>((value)))))),span));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U32>();
-u32 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 5: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((infallible_integer_cast<u64>((value)))))),span));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::U64>();
-u64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I8>();
-i8 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 7: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I16>((infallible_integer_cast<i16>((value)))))),span));
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((infallible_integer_cast<i32>((value)))))),span));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((infallible_integer_cast<i64>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I16>();
-i16 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 8: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I32>((infallible_integer_cast<i32>((value)))))),span));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((infallible_integer_cast<i64>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I32>();
-i32 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 9: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::I64>((infallible_integer_cast<i64>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::I64>();
-i64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 12: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::USize>((infallible_integer_cast<size_t>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::ValueImpl::USize>();
-size_t const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 5: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::U64>((infallible_integer_cast<u64>((value)))))),span));
-};/*case end*/
-case 16: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::CInt>((infallible_integer_cast<int>((value)))))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-case 24: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::Value, ErrorOr<types::Value>>{
-auto&& __jakt_match_variant = *((expected).impl);
-switch(__jakt_match_variant.index()) {
-case 24: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(*this))),span));
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(types::Value(TRY((types::ValueImpl::template __jakt_create<typename types::ValueImpl::OptionalSome>(*this))),span));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(*this);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-}/*switch end*/
-}()
-)));
+return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<types::Value>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<types::Value>> {
+{
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::Value> const maybe_binding = ((((scope)->comptime_bindings)).get(name));
+if (((maybe_binding).has_value())){
+return ( typename utility::IterationDecision<types::Value> { typename utility::IterationDecision<types::Value>::Break((maybe_binding.value())) } );
 }
+return ( typename utility::IterationDecision<types::Value> { typename utility::IterationDecision<types::Value>::Continue() } );
 }
-
-DeprecatedString types::Value::type_name() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, DeprecatedString>{
-auto&& __jakt_match_variant = *((*this).impl);
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("void"sv));
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("bool"sv));
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u8"sv));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u16"sv));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u32"sv));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("u64"sv));
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i18"sv));
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i16"sv));
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i32"sv));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("i64"sv));
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("f32"sv));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("f64"sv));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("usize"sv));
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("String"sv));
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("StringView"sv));
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("c_char"sv));
-};/*case end*/
-case 16: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("c_int"sv));
-};/*case end*/
-case 17: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("struct <T>"sv));
-};/*case end*/
+}
+)))))));
+}
+}
+
+ErrorOr<types::TypeId> types::CheckedProgram::substitute_typevars_in_type_helper(types::TypeId const type_id,types::GenericInferences const generic_inferences,types::ModuleId const module_id) {
+{
+NonnullRefPtr<typename types::Type> const type_ = ((*this).get_type(type_id));
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, ErrorOr<types::TypeId>>{
+auto&& __jakt_match_variant = *type_;
+switch(__jakt_match_variant.index()) {
 case 18: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("class <T>"sv));
+{
+JaktInternal::Optional<DeprecatedString> const replacment_type_id_string = ((generic_inferences).get(TRY((((type_id).to_string())))));
+if (((replacment_type_id_string).has_value())){
+return (TRY((types::TypeId::from_string(((replacment_type_id_string).value())))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+{
+JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((new_args).ensure_capacity(((args).size())))));
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::TypeId arg = (_magic_value.value());
+{
+TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(arg,generic_inferences,module_id))))))));
+}
+
+}
+}
+
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericTraitInstance>(id,new_args))),module_id)))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 19: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("enum <T>"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+{
+JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((new_args).ensure_capacity(((args).size())))));
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::TypeId arg = (_magic_value.value());
+{
+TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(arg,generic_inferences,module_id))))))));
+}
+
+}
+}
+
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(id,new_args))),module_id)))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 20: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Array"sv));
-};/*case end*/
-case 21: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Dictionary"sv));
-};/*case end*/
-case 22: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Set"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+{
+JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((new_args).ensure_capacity(((args).size())))));
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::TypeId arg = (_magic_value.value());
+{
+TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(arg,generic_inferences,module_id))))))));
+}
+
+}
+}
+
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericEnumInstance>(id,new_args))),module_id)))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 23: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("raw <T>"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+{
+types::CheckedStruct const struct_ = ((*this).get_struct(struct_id));
+if ((!(((((struct_).generic_parameters)).is_empty())))){
+JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((new_args).ensure_capacity(((((struct_).generic_parameters)).size())))));
+{
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((struct_).generic_parameters)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedGenericParameter arg = (_magic_value.value());
+{
+TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(((arg).type_id),generic_inferences,module_id))))))));
+}
+
+}
+}
+
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericInstance>(struct_id,new_args))),module_id)))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 24: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Some"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+{
+types::CheckedEnum const enum_ = ((*this).get_enum(enum_id));
+if ((!(((((enum_).generic_parameters)).is_empty())))){
+JaktInternal::DynamicArray<types::TypeId> new_args = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((new_args).ensure_capacity(((((enum_).generic_parameters)).size())))));
+{
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((((enum_).generic_parameters)).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::CheckedGenericParameter arg = (_magic_value.value());
+{
+TRY((((new_args).push(TRY((((*this).substitute_typevars_in_type(((arg).type_id),generic_inferences,module_id))))))));
+}
+
+}
+}
+
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::GenericEnumInstance>(enum_id,new_args))),module_id)))));
+}
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 25: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("None"sv));
-};/*case end*/
-case 26: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Tuple"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
+types::TypeId const& rawptr_type_id = __jakt_match_value.value;
+{
+NonnullRefPtr<typename types::Type> const rawptr_type = TRY((types::Type::template __jakt_create<typename types::Type::RawPtr>(TRY((((*this).substitute_typevars_in_type(rawptr_type_id,generic_inferences,module_id)))))));
+return (TRY((((*this).find_or_add_type_id(rawptr_type,module_id)))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 case 27: {
-return JaktInternal::ExplicitValue(Jakt::DeprecatedString("Function"sv));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
+types::TypeId const& ref_type_id = __jakt_match_value.value;
+{
+NonnullRefPtr<typename types::Type> const ref_type = TRY((types::Type::template __jakt_create<typename types::Type::Reference>(TRY((((*this).substitute_typevars_in_type(ref_type_id,generic_inferences,module_id)))))));
+return (TRY((((*this).find_or_add_type_id(ref_type,module_id)))));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
+types::TypeId const& ref_type_id = __jakt_match_value.value;
+{
+NonnullRefPtr<typename types::Type> const ref_type = TRY((types::Type::template __jakt_create<typename types::Type::MutableReference>(TRY((((*this).substitute_typevars_in_type(ref_type_id,generic_inferences,module_id)))))));
+return (TRY((((*this).find_or_add_type_id(ref_type,module_id)))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
+bool const& can_throw = __jakt_match_value.can_throw;
+types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
+types::FunctionId const& pseudo_function_id = __jakt_match_value.pseudo_function_id;
+{
+JaktInternal::DynamicArray<types::TypeId> new_params = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+TRY((((new_params).ensure_capacity(((params).size())))));
+bool is_different = false;
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((params).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+types::TypeId param = (_magic_value.value());
+{
+types::TypeId const new_param = TRY((((*this).substitute_typevars_in_type(param,generic_inferences,module_id))));
+(is_different = (is_different || (!(((new_param).equals(param))))));
+TRY((((new_params).push(new_param))));
 }
 
-ErrorOr<DeprecatedString> types::VarId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("VarId("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::VarId::VarId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
+}
 
-ErrorOr<DeprecatedString> types::TypecheckFunctions::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("TypecheckFunctions("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("block: {}", block));
+types::TypeId const return_type_substitute = TRY((((*this).substitute_typevars_in_type(return_type_id,generic_inferences,module_id))));
+(is_different = (is_different || (!(((return_type_substitute).equals(return_type_id))))));
+if ((!(is_different))){
+return (type_id);
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::TypecheckFunctions::TypecheckFunctions(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> a_block): block(move(a_block)){}
-ErrorOr<NonnullRefPtr<TypecheckFunctions>> types::TypecheckFunctions::__jakt_create(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> block) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) TypecheckFunctions (move(block)))); return o; }
-ErrorOr<DeprecatedString> types::CheckedParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedParameter("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("requires_label: {}, ", requires_label));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("variable: {}, ", *variable));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("default_value: {}", default_value));
+NonnullRefPtr<types::CheckedFunction> const previous_function = ((*this).get_function(pseudo_function_id));
+JaktInternal::DynamicArray<types::CheckedParameter> replacement_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((previous_function)->params)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+types::CheckedParameter const param = ((((previous_function)->params))[i]);
+types::CheckedParameter const new_param = types::CheckedParameter(((param).requires_label),TRY((types::CheckedVariable::__jakt_create(((((param).variable))->name),((new_params)[i]),((((param).variable))->is_mutable),((((param).variable))->definition_span),((((param).variable))->type_span),((((param).variable))->visibility),JaktInternal::OptionalNone()))),((param).default_value));
+TRY((((replacement_params).push(new_param))));
+}
+
+}
+}
+
+NonnullRefPtr<types::CheckedFunction> const new_function = TRY((types::CheckedFunction::__jakt_create(((previous_function)->name),((previous_function)->name_span),((previous_function)->visibility),return_type_substitute,((previous_function)->return_type_span),replacement_params,((previous_function)->generics),((previous_function)->block),can_throw,((previous_function)->type),((previous_function)->linkage),((previous_function)->function_scope_id),((previous_function)->struct_id),((previous_function)->is_instantiated),((previous_function)->parsed_function),((previous_function)->is_comptime),((previous_function)->is_virtual),((previous_function)->is_override),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone(),JaktInternal::OptionalNone())));
+types::FunctionId const new_function_id = TRY((((((((*this).modules))[((module_id).id)]))->add_function(new_function))));
+return (TRY((((*this).find_or_add_type_id(TRY((types::Type::template __jakt_create<typename types::Type::Function>(new_params,can_throw,return_type_substitute,new_function_id))),module_id)))));
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+default: {
+{
+return (type_id);
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+}/*switch end*/
+}()
+));
+return (type_id);
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<types::CheckedParameter> types::CheckedParameter::map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) const {
+}
+
+i64 types::CheckedProgram::get_bits(types::TypeId const type_id) const {
 {
-return (types::CheckedParameter(((*this).requires_label),TRY((((((*this).variable))->map_types(map)))),((*this).default_value)));
+return (((((*this).get_type(type_id)))->get_bits()));
 }
 }
 
-types::CheckedParameter::CheckedParameter(bool a_requires_label, NonnullRefPtr<types::CheckedVariable> a_variable, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> a_default_value) :requires_label(move(a_requires_label)), variable(move(a_variable)), default_value(move(a_default_value)){}
-
-ErrorOr<DeprecatedString> types::CheckedCall::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedCall("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespace_: {}, ", namespace_));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("args: {}, ", args));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_args: {}, ", type_args));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("function_id: {}, ", function_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("return_type: {}, ", return_type));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("callee_throws: {}, ", callee_throws));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}", external_name));
+NonnullRefPtr<typename types::Type> types::CheckedProgram::get_type(types::TypeId const id) const {
+{
+return (((((((((*this).modules))[((((id).module)).id)]))->types))[((id).id)]));
+}
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedCall::CheckedCall(JaktInternal::DynamicArray<types::ResolvedNamespace> a_namespace_, DeprecatedString a_name, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> a_args, JaktInternal::DynamicArray<types::TypeId> a_type_args, JaktInternal::Optional<types::FunctionId> a_function_id, types::TypeId a_return_type, bool a_callee_throws, JaktInternal::Optional<DeprecatedString> a_external_name) :namespace_(move(a_namespace_)), name(move(a_name)), args(move(a_args)), type_args(move(a_type_args)), function_id(move(a_function_id)), return_type(move(a_return_type)), callee_throws(move(a_callee_throws)), external_name(move(a_external_name)){}
 
-DeprecatedString types::CheckedCall::name_for_codegen() const {
+ErrorOr<types::TypeId> types::CheckedProgram::find_or_add_type_id(NonnullRefPtr<typename types::Type> const type,types::ModuleId const module_id) {
 {
-return (((*this).external_name).value_or_lazy_evaluated([&] { return ((*this).name); }));
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<types::Module>> _magic = ((((*this).modules)).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<types::Module>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
+NonnullRefPtr<types::Module> module = (_magic_value.value());
+{
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((module)->types)).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t id = (_magic_value.value());
+{
+if (((((((module)->types))[id]))->equals(type))){
+return (types::TypeId(((module)->id),id));
 }
-
-ErrorOr<DeprecatedString> types::CheckedVarDecl::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedVarDecl("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_mutable: {}, ", is_mutable));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}", type_id));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedVarDecl::CheckedVarDecl(DeprecatedString a_name, bool a_is_mutable, utility::Span a_span, types::TypeId a_type_id) :name(move(a_name)), is_mutable(move(a_is_mutable)), span(move(a_span)), type_id(move(a_type_id)){}
 
-ErrorOr<DeprecatedString> types::CheckedNamespace::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedNamespace("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scope: {}", scope));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedNamespace::CheckedNamespace(DeprecatedString a_name, types::ScopeId a_scope) :name(move(a_name)), scope(move(a_scope)){}
+}
 
-ErrorOr<DeprecatedString> types::CheckedGenericParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedGenericParameter("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}, ", type_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("constraints: {}, ", constraints));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedGenericParameter::CheckedGenericParameter(types::TypeId a_type_id, JaktInternal::DynamicArray<types::TraitId> a_constraints, utility::Span a_span) :type_id(move(a_type_id)), constraints(move(a_constraints)), span(move(a_span)){}
 
-ErrorOr<types::CheckedGenericParameter> types::CheckedGenericParameter::make(types::TypeId const type_id,utility::Span const span) {
-{
-return (types::CheckedGenericParameter(type_id,(TRY((DynamicArray<types::TraitId>::create_with({})))),span));
 }
 }
 
-ErrorOr<DeprecatedString> types::CheckedBlock::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedBlock("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("statements: {}, ", statements));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scope_id: {}, ", scope_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("control_flow: {}, ", control_flow));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("yielded_type: {}, ", yielded_type));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("yielded_none: {}", yielded_none));
+TRY((((((((((*this).modules))[((module_id).id)]))->types)).push(type))));
+return (types::TypeId(module_id,(JaktInternal::checked_sub<size_t>(((((((((*this).modules))[((module_id).id)]))->types)).size()),static_cast<size_t>(1ULL)))));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedBlock::CheckedBlock(JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> a_statements, types::ScopeId a_scope_id, types::BlockControlFlow a_control_flow, JaktInternal::Optional<types::TypeId> a_yielded_type, bool a_yielded_none) :statements(move(a_statements)), scope_id(move(a_scope_id)), control_flow(move(a_control_flow)), yielded_type(move(a_yielded_type)), yielded_none(move(a_yielded_none)){}
-
-ErrorOr<DeprecatedString> types::TraitId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("TraitId("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-bool types::TraitId::equals(types::TraitId const other) const {
+
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>>> types::CheckedProgram::find_namespace_in_scope(types::ScopeId const scope_id,DeprecatedString const name,bool const treat_aliases_as_imports) const {
 {
-return (((((((*this).module)).id) == ((((other).module)).id)) && (((*this).id) == ((other).id))));
+return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<JaktInternal::Tuple<types::ScopeId,bool>>(scope_id,(([name, treat_aliases_as_imports, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>>> {
+{
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<DeprecatedString> const effective_name = name_override.value_or_lazy_evaluated_optional([&] { return ((scope)->namespace_name); });
+bool const is_import = (((name_override).has_value()) && (!(is_alias)));
+if ((((effective_name).has_value()) && ((effective_name.value()) == name))){
+return ( typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>> { typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>>::Break((Tuple{scope_id, (is_import || (is_alias && treat_aliases_as_imports))})) } );
 }
+return ( typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>> { typename utility::IterationDecision<JaktInternal::Tuple<types::ScopeId,bool>>::Continue() } );
 }
-
-types::TraitId::TraitId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
-
-ErrorOr<DeprecatedString> types::FunctionId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("FunctionId("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-bool types::FunctionId::equals(types::FunctionId const rhs) const {
-{
-return (((((((*this).module)).id) == ((((rhs).module)).id)) && (((*this).id) == ((rhs).id))));
+)))))));
 }
 }
 
-types::FunctionId::FunctionId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
-
-ErrorOr<DeprecatedString> types::Module::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Module("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}, ", id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("functions: {}, ", functions));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("structures: {}, ", structures));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("enums: {}, ", enums));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scopes: {}, ", scopes));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("types: {}, ", types));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("variables: {}, ", variables));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("imports: {}, ", imports));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("resolved_import_path: \"{}\", ", resolved_import_path));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_root: {}", is_root));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::Module::Module(types::ModuleId a_id, DeprecatedString a_name, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> a_functions, JaktInternal::DynamicArray<types::CheckedStruct> a_structures, JaktInternal::DynamicArray<types::CheckedEnum> a_enums, JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> a_scopes, JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> a_types, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> a_traits, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> a_variables, JaktInternal::DynamicArray<types::ModuleId> a_imports, DeprecatedString a_resolved_import_path, bool a_is_root): id(move(a_id)), name(move(a_name)), functions(move(a_functions)), structures(move(a_structures)), enums(move(a_enums)), scopes(move(a_scopes)), types(move(a_types)), traits(move(a_traits)), variables(move(a_variables)), imports(move(a_imports)), resolved_import_path(move(a_resolved_import_path)), is_root(move(a_is_root)){}
-ErrorOr<NonnullRefPtr<Module>> types::Module::__jakt_create(types::ModuleId id, DeprecatedString name, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> functions, JaktInternal::DynamicArray<types::CheckedStruct> structures, JaktInternal::DynamicArray<types::CheckedEnum> enums, JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> scopes, JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> types, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> traits, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> variables, JaktInternal::DynamicArray<types::ModuleId> imports, DeprecatedString resolved_import_path, bool is_root) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Module (move(id), move(name), move(functions), move(structures), move(enums), move(scopes), move(types), move(traits), move(variables), move(imports), move(resolved_import_path), move(is_root)))); return o; }
-ErrorOr<types::TypeId> types::Module::new_type_variable(JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const implemented_traits) {
+ErrorOr<JaktInternal::Optional<types::TraitId>> types::CheckedProgram::find_trait_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
 {
-size_t const new_id = ((((*this).types)).size());
-JaktInternal::DynamicArray<types::TypeId> const empty_implementation = (TRY((DynamicArray<types::TypeId>::create_with({}))));
-JaktInternal::DynamicArray<types::TypeId> const trait_implementations = implemented_traits.value_or_lazy_evaluated([&] { return empty_implementation; });
-TRY((((((*this).types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(TRY((__jakt_format(Jakt::DeprecatedString("T{}"sv),new_id))),trait_implementations)))))));
-return (types::TypeId(((*this).id),new_id));
+return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<types::TraitId>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<types::TraitId>> {
+{
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::TraitId> const maybe_trait = ((((scope)->traits)).get(name));
+if (((maybe_trait).has_value())){
+return ( typename utility::IterationDecision<types::TraitId> { typename utility::IterationDecision<types::TraitId>::Break((maybe_trait.value())) } );
+}
+return ( typename utility::IterationDecision<types::TraitId> { typename utility::IterationDecision<types::TraitId>::Continue() } );
+}
+}
+)))))));
 }
 }
 
-ErrorOr<types::FunctionId> types::Module::add_function(NonnullRefPtr<types::CheckedFunction> const checked_function) {
+types::CheckedEnum types::CheckedProgram::get_enum(types::EnumId const id) const {
 {
-types::FunctionId const new_id = ((*this).next_function_id());
-TRY((((((*this).functions)).push(checked_function))));
-return (new_id);
+return (((((((((*this).modules))[((((id).module)).id)]))->enums))[((id).id)]));
 }
 }
 
-bool types::Module::is_prelude() const {
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>>> types::CheckedProgram::find_functions_with_name_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
 {
-return ((((((*this).id)).id) == static_cast<size_t>(0ULL)));
+return (((TRY((((*this).find_scoped_functions_with_name_in_scope(parent_scope_id,function_name))))).map([](auto& _value) { return _value.template get<0>(); })));
 }
 }
 
-ErrorOr<types::VarId> types::Module::add_variable(NonnullRefPtr<types::CheckedVariable> const checked_variable) {
+ErrorOr<JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>>> types::CheckedProgram::find_var_in_scope(types::ScopeId const scope_id,DeprecatedString const var) const {
 {
-size_t const new_id = ((((*this).variables)).size());
-TRY((((((*this).variables)).push(checked_variable))));
-return (types::VarId(((*this).id),new_id));
+return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<NonnullRefPtr<types::CheckedVariable>>(scope_id,(([var, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>>> {
+{
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::VarId> const maybe_var = ((((scope)->vars)).get(var));
+if (((maybe_var).has_value())){
+return ( typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>> { typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>>::Break(((*this).get_variable((maybe_var.value())))) } );
+}
+return ( typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>> { typename utility::IterationDecision<NonnullRefPtr<types::CheckedVariable>>::Continue() } );
+}
+}
+)))))));
 }
 }
 
-types::FunctionId types::Module::next_function_id() const {
+ErrorOr<JaktInternal::Optional<types::FunctionId>> types::CheckedProgram::find_function_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
 {
-return (types::FunctionId(((*this).id),((((*this).functions)).size())));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const results = TRY((((*this).find_functions_with_name_in_scope(parent_scope_id,function_name))));
+if ((!(((results).has_value())))){
+return (JaktInternal::OptionalNone());
 }
+JaktInternal::DynamicArray<types::FunctionId> const functions = ((results).value());
+if ((((functions).size()) != static_cast<size_t>(1ULL))){
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("internal error: found multiple (or no) functions with name '{}'"sv),function_name)))))));
 }
-
-ErrorOr<DeprecatedString> types::CheckedTrait::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedTrait("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("methods: {}, ", methods));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_parameters: {}, ", generic_parameters));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scope_id: {}", scope_id));
+return (((functions)[static_cast<i64>(0LL)]));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedTrait::CheckedTrait(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> a_methods, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, types::ScopeId a_scope_id): name(move(a_name)), name_span(move(a_name_span)), methods(move(a_methods)), generic_parameters(move(a_generic_parameters)), scope_id(move(a_scope_id)){}
-ErrorOr<NonnullRefPtr<CheckedTrait>> types::CheckedTrait::__jakt_create(DeprecatedString name, utility::Span name_span, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> methods, JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters, types::ScopeId scope_id) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) CheckedTrait (move(name), move(name_span), move(methods), move(generic_parameters), move(scope_id)))); return o; }
-ErrorOr<DeprecatedString> types::CheckedFunction::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedFunction("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("visibility: {}, ", visibility));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("return_type_id: {}, ", return_type_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("return_type_span: {}, ", return_type_span));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("params: {}, ", params));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generics: {}, ", *generics));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("block: {}, ", block));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("can_throw: {}, ", can_throw));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type: {}, ", type));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("linkage: {}, ", linkage));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("function_scope_id: {}, ", function_scope_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("struct_id: {}, ", struct_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_instantiated: {}, ", is_instantiated));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parsed_function: {}, ", parsed_function));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_comptime: {}, ", is_comptime));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_virtual: {}, ", is_virtual));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_override: {}, ", is_override));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("specialization_index: {}, ", specialization_index));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("owner_scope: {}, ", owner_scope));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}, ", external_name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("deprecated_message: {}, ", deprecated_message));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("stores_arguments: {}", stores_arguments));
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<bool> types::CheckedFunction::signature_matches(NonnullRefPtr<types::CheckedFunction> const other) const {
+
+types::CheckedStruct types::CheckedProgram::get_struct(types::StructId const id) const {
 {
-if ((((((*this).name) != ((other)->name)) || (((*this).can_throw) != ((other)->can_throw))) || (((*this).is_comptime) != ((other)->is_comptime)))){
-return (false);
-}
-if ((((((*this).params)).size()) != ((((other)->params)).size()))){
-return (false);
+return (((((((((*this).modules))[((((id).module)).id)]))->structures))[((id).id)]));
 }
-if ((((((((*this).generics))->params)).size()) != ((((((other)->generics))->params)).size()))){
-return (false);
 }
-JaktInternal::Set<DeprecatedString> lhs_generic_type_ids = (TRY((Set<DeprecatedString>::create_with_values({}))));
-JaktInternal::Set<DeprecatedString> rhs_generic_type_ids = (TRY((Set<DeprecatedString>::create_with_values({}))));
+
+ErrorOr<JaktInternal::Optional<types::StructId>> types::CheckedProgram::check_and_extract_weak_ptr(types::StructId const struct_id,JaktInternal::DynamicArray<types::TypeId> const args) const {
 {
-JaktInternal::ArrayIterator<types::FunctionGenericParameter> _magic = ((((((*this).generics))->params)).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionGenericParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+types::StructId const weak_ptr_struct_id = TRY((((*this).find_struct_in_prelude(Jakt::DeprecatedString("WeakPtr"sv)))));
+if (((struct_id).equals(weak_ptr_struct_id))){
+if ((((args).size()) != static_cast<size_t>(1ULL))){
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("Internal error: Generic type is WeakPtr but there are not exactly 1 type parameter. There are {} parameters."sv),((args).size()))))))));
+}
+types::TypeId const inner_type_id = ((args)[static_cast<i64>(0LL)]);
+NonnullRefPtr<typename types::Type> const inner_type = ((*this).get_type(inner_type_id));
+if (((inner_type)->index() == 23 /* Struct */)){
+types::StructId const inner_struct_id = ((inner_type)->get<types::Type::Struct>()).value;
+return (inner_struct_id);
 }
-types::FunctionGenericParameter param = (_magic_value.value());
-{
-types::TypeId const type_id = ((param).type_id());
-TRY((((lhs_generic_type_ids).add(TRY((((type_id).to_string())))))));
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Internal error: Inner type of WeakPtr is not a struct. It is {}."sv),inner_type))));
+}
+else {
+return (JaktInternal::OptionalNone());
 }
 
 }
 }
 
+ErrorOr<JaktInternal::Optional<types::EnumId>> types::CheckedProgram::find_enum_in_scope(types::ScopeId const scope_id,DeprecatedString const name) const {
 {
-JaktInternal::ArrayIterator<types::FunctionGenericParameter> _magic = ((((((other)->generics))->params)).iterator());
-for (;;){
-JaktInternal::Optional<types::FunctionGenericParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::FunctionGenericParameter param = (_magic_value.value());
+return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<types::EnumId>(scope_id,(([name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<types::EnumId>> {
 {
-types::TypeId const type_id = ((param).type_id());
-TRY((((rhs_generic_type_ids).add(TRY((((type_id).to_string())))))));
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<types::EnumId> const maybe_enum = ((((scope)->enums)).get(name));
+if (((maybe_enum).has_value())){
+return ( typename utility::IterationDecision<types::EnumId> { typename utility::IterationDecision<types::EnumId>::Break((maybe_enum.value())) } );
 }
-
+return ( typename utility::IterationDecision<types::EnumId> { typename utility::IterationDecision<types::EnumId>::Continue() } );
+}
+}
+)))))));
 }
 }
 
+JaktInternal::Optional<types::LoadedModule> types::CheckedProgram::get_loaded_module(DeprecatedString const module_name) const {
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((((*this).params)).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+return (((((*this).loaded_modules)).get(module_name)));
 }
-size_t param_index = (_magic_value.value());
+}
+
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> types::CheckedProgram::find_scoped_functions_with_name_in_scope(types::ScopeId const parent_scope_id,DeprecatedString const function_name) const {
 {
-types::CheckedParameter const lhs_param = ((((*this).params))[param_index]);
-types::CheckedParameter const rhs_param = ((((other)->params))[param_index]);
-DeprecatedString const lhs_param_id = TRY((((((((lhs_param).variable))->type_id)).to_string())));
-DeprecatedString const rhs_param_id = TRY((((((((rhs_param).variable))->type_id)).to_string())));
-if (((!(((((((lhs_param).variable))->type_id)).equals(((((rhs_param).variable))->type_id))))) && (!((((lhs_generic_type_ids).contains(lhs_param_id)) && ((rhs_generic_type_ids).contains(rhs_param_id))))))){
-return (false);
+return (TRY((((*this).template for_each_scope_accessible_unqualified_from_scope<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>(parent_scope_id,(([function_name, this](types::ScopeId scope_id, JaktInternal::Optional<DeprecatedString> name_override, bool is_alias) -> ErrorOr<typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> {
+{
+NonnullRefPtr<types::Scope> const scope = TRY((((*this).get_scope(scope_id))));
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const maybe_functions = ((((scope)->functions)).get(function_name));
+if (((maybe_functions).has_value())){
+return ( typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>> { typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>::Break((Tuple{(maybe_functions.value()), scope_id})) } );
 }
+return ( typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>> { typename utility::IterationDecision<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>::Continue() } );
 }
-
+}
+)))))));
 }
 }
 
-return (true);
+bool types::CheckedProgram::is_signed(types::TypeId const type_id) const {
+{
+return (((((*this).get_type(type_id)))->is_signed()));
 }
 }
 
-bool types::CheckedFunction::is_static() const {
+bool types::CheckedProgram::is_numeric(types::TypeId const type_id) const {
 {
-if ((((((*this).params)).size()) < static_cast<size_t>(1ULL))){
-return (true);
-}
-return ((((((((((*this).params))[static_cast<i64>(0LL)])).variable))->name) != Jakt::DeprecatedString("this"sv)));
+return ((((*this).is_integer(type_id)) || ((*this).is_floating(type_id))));
 }
 }
 
-types::CheckedFunction::CheckedFunction(DeprecatedString a_name, utility::Span a_name_span, types::CheckedVisibility a_visibility, types::TypeId a_return_type_id, JaktInternal::Optional<utility::Span> a_return_type_span, JaktInternal::DynamicArray<types::CheckedParameter> a_params, NonnullRefPtr<types::FunctionGenerics> a_generics, types::CheckedBlock a_block, bool a_can_throw, parser::FunctionType a_type, parser::FunctionLinkage a_linkage, types::ScopeId a_function_scope_id, JaktInternal::Optional<types::StructId> a_struct_id, bool a_is_instantiated, JaktInternal::Optional<parser::ParsedFunction> a_parsed_function, bool a_is_comptime, bool a_is_virtual, bool a_is_override, JaktInternal::Optional<size_t> a_specialization_index, JaktInternal::Optional<types::ScopeId> a_owner_scope, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Optional<DeprecatedString> a_deprecated_message, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> a_stores_arguments): name(move(a_name)), name_span(move(a_name_span)), visibility(move(a_visibility)), return_type_id(move(a_return_type_id)), return_type_span(move(a_return_type_span)), params(move(a_params)), generics(move(a_generics)), block(move(a_block)), can_throw(move(a_can_throw)), type(move(a_type)), linkage(move(a_linkage)), function_scope_id(move(a_function_scope_id)), struct_id(move(a_struct_id)), is_instantiated(move(a_is_instantiated)), parsed_function(move(a_parsed_function)), is_comptime(move(a_is_comptime)), is_virtual(move(a_is_virtual)), is_override(move(a_is_override)), specialization_index(move(a_specialization_index)), owner_scope(move(a_owner_scope)), external_name(move(a_external_name)), deprecated_message(move(a_deprecated_message)), stores_arguments(move(a_stores_arguments)){}
-ErrorOr<NonnullRefPtr<CheckedFunction>> types::CheckedFunction::__jakt_create(DeprecatedString name, utility::Span name_span, types::CheckedVisibility visibility, types::TypeId return_type_id, JaktInternal::Optional<utility::Span> return_type_span, JaktInternal::DynamicArray<types::CheckedParameter> params, NonnullRefPtr<types::FunctionGenerics> generics, types::CheckedBlock block, bool can_throw, parser::FunctionType type, parser::FunctionLinkage linkage, types::ScopeId function_scope_id, JaktInternal::Optional<types::StructId> struct_id, bool is_instantiated, JaktInternal::Optional<parser::ParsedFunction> parsed_function, bool is_comptime, bool is_virtual, bool is_override, JaktInternal::Optional<size_t> specialization_index, JaktInternal::Optional<types::ScopeId> owner_scope, JaktInternal::Optional<DeprecatedString> external_name, JaktInternal::Optional<DeprecatedString> deprecated_message, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> stores_arguments) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) CheckedFunction (move(name), move(name_span), move(visibility), move(return_type_id), move(return_type_span), move(params), move(generics), move(block), move(can_throw), move(type), move(linkage), move(function_scope_id), move(struct_id), move(is_instantiated), move(parsed_function), move(is_comptime), move(is_virtual), move(is_override), move(specialization_index), move(owner_scope), move(external_name), move(deprecated_message), move(stores_arguments)))); return o; }
-parser::ParsedFunction types::CheckedFunction::to_parsed_function() const {
+ErrorOr<types::StructOrEnumId> types::CheckedProgram::find_reflected_primitive(DeprecatedString const primitive) const {
 {
-if ((!(((((*this).parsed_function)).has_value())))){
-utility::panic(Jakt::DeprecatedString("to_parsed_function() called on a synthetic function"sv));
+types::ScopeId const scope_id = ((*this).prelude_scope_id());
+JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const maybe_namespace = TRY((((*this).find_namespace_in_scope(scope_id,Jakt::DeprecatedString("Reflect"sv),false))));
+if ((!(((maybe_namespace).has_value())))){
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("internal error: builtin namespace 'Reflect' not found"sv))))))));
 }
-return ((((*this).parsed_function).value()));
+types::ScopeId const reflect_namespace_scope_id = (((maybe_namespace.value())).template get<0>());
+JaktInternal::Optional<types::EnumId> const enum_id = TRY((((*this).find_enum_in_scope(reflect_namespace_scope_id,primitive))));
+if (((enum_id).has_value())){
+return ( types::StructOrEnumId { typename types::StructOrEnumId::Enum((enum_id.value())) } );
+}
+JaktInternal::Optional<types::StructId> const struct_id = TRY((((*this).find_struct_in_scope(reflect_namespace_scope_id,primitive))));
+if (((struct_id).has_value())){
+return ( types::StructOrEnumId { typename types::StructOrEnumId::Struct((struct_id.value())) } );
+}
+TRY((((((*this).compiler))->panic(TRY((__jakt_format(Jakt::DeprecatedString("internal error: definition for reflect builtin '{}' not found"sv),primitive)))))));
 }
 }
 
-bool types::CheckedFunction::is_specialized_for_types(JaktInternal::DynamicArray<types::TypeId> const types) const {
-{
-return (((((*this).generics))->is_specialized_for_types(types)));
+ErrorOr<DeprecatedString> types::ResolvedNamespace::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ResolvedNamespace("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}, ", external_name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_parameters: {}", generic_parameters));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::ResolvedNamespace::ResolvedNamespace(DeprecatedString a_name, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> a_generic_parameters) :name(move(a_name)), external_name(move(a_external_name)), generic_parameters(move(a_generic_parameters)){}
+
+ErrorOr<DeprecatedString> types::TypecheckFunctions::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("TypecheckFunctions("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("block: {}", block));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::TypecheckFunctions::TypecheckFunctions(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> a_block): block(move(a_block)){}
+ErrorOr<NonnullRefPtr<TypecheckFunctions>> types::TypecheckFunctions::__jakt_create(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> block) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) TypecheckFunctions (move(block)))); return o; }
+ErrorOr<DeprecatedString> types::CheckedStruct::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedStruct("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name_span: {}, ", name_span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_parameters: {}, ", generic_parameters));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("fields: {}, ", fields));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scope_id: {}, ", scope_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("definition_linkage: {}, ", definition_linkage));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("trait_implementations: {}, ", trait_implementations));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("record_type: {}, ", record_type));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}, ", type_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("super_struct_id: {}, ", super_struct_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}", external_name));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::CheckedStruct::CheckedStruct(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<types::CheckedField> a_fields, types::ScopeId a_scope_id, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> a_trait_implementations, parser::RecordType a_record_type, types::TypeId a_type_id, JaktInternal::Optional<types::StructId> a_super_struct_id, JaktInternal::Optional<DeprecatedString> a_external_name) :name(move(a_name)), name_span(move(a_name_span)), generic_parameters(move(a_generic_parameters)), fields(move(a_fields)), scope_id(move(a_scope_id)), definition_linkage(move(a_definition_linkage)), trait_implementations(move(a_trait_implementations)), record_type(move(a_record_type)), type_id(move(a_type_id)), super_struct_id(move(a_super_struct_id)), external_name(move(a_external_name)){}
 
-ErrorOr<NonnullRefPtr<types::CheckedFunction>> types::CheckedFunction::copy() const {
+DeprecatedString types::CheckedStruct::name_for_codegen() const {
 {
-return (TRY((types::CheckedFunction::__jakt_create(((*this).name),((*this).name_span),((*this).visibility),((*this).return_type_id),((*this).return_type_span),((*this).params),((*this).generics),((*this).block),((*this).can_throw),((*this).type),((*this).linkage),((*this).function_scope_id),((*this).struct_id),((*this).is_instantiated),((*this).parsed_function),((*this).is_comptime),((*this).is_virtual),((*this).is_override),((*this).specialization_index),((*this).owner_scope),((*this).external_name),((*this).deprecated_message),((*this).stores_arguments)))));
+return (((*this).external_name).value_or_lazy_evaluated([&] { return ((*this).name); }));
 }
 }
 
-ErrorOr<void> types::CheckedFunction::add_param(types::CheckedParameter const checked_param) {
+ErrorOr<DeprecatedString> types::CheckedParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedParameter("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("requires_label: {}, ", requires_label));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("variable: {}, ", *variable));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("default_value: {}", default_value));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<types::CheckedParameter> types::CheckedParameter::map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) const {
 {
-TRY((((((*this).params)).push(checked_param))));
-TRY((((((((*this).generics))->base_params)).push(checked_param))));
+return (types::CheckedParameter(((*this).requires_label),TRY((((((*this).variable))->map_types(map)))),((*this).default_value)));
 }
-return {};
 }
 
-ErrorOr<void> types::CheckedFunction::map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) {
-{
-(((*this).return_type_id) = TRY((map(((*this).return_type_id)))));
-JaktInternal::DynamicArray<types::CheckedParameter> changed_params = (TRY((DynamicArray<types::CheckedParameter>::create_with({}))));
-{
-JaktInternal::ArrayIterator<types::CheckedParameter> _magic = ((((*this).params)).iterator());
-for (;;){
-JaktInternal::Optional<types::CheckedParameter> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+types::CheckedParameter::CheckedParameter(bool a_requires_label, NonnullRefPtr<types::CheckedVariable> a_variable, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> a_default_value) :requires_label(move(a_requires_label)), variable(move(a_variable)), default_value(move(a_default_value)){}
+
+ErrorOr<DeprecatedString> types::CheckedCall::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedCall("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespace_: {}, ", namespace_));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("args: {}, ", args));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_args: {}, ", type_args));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("function_id: {}, ", function_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("return_type: {}, ", return_type));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("callee_throws: {}, ", callee_throws));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}", external_name));
 }
-types::CheckedParameter param = (_magic_value.value());
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::CheckedCall::CheckedCall(JaktInternal::DynamicArray<types::ResolvedNamespace> a_namespace_, DeprecatedString a_name, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> a_args, JaktInternal::DynamicArray<types::TypeId> a_type_args, JaktInternal::Optional<types::FunctionId> a_function_id, types::TypeId a_return_type, bool a_callee_throws, JaktInternal::Optional<DeprecatedString> a_external_name) :namespace_(move(a_namespace_)), name(move(a_name)), args(move(a_args)), type_args(move(a_type_args)), function_id(move(a_function_id)), return_type(move(a_return_type)), callee_throws(move(a_callee_throws)), external_name(move(a_external_name)){}
+
+DeprecatedString types::CheckedCall::name_for_codegen() const {
 {
-TRY((((changed_params).push(TRY((((param).map_types(map))))))));
+return (((*this).external_name).value_or_lazy_evaluated([&] { return ((*this).name); }));
 }
-
 }
+
+ErrorOr<DeprecatedString> types::CheckedVarDecl::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedVarDecl("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_mutable: {}, ", is_mutable));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}, ", span));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}", type_id));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::CheckedVarDecl::CheckedVarDecl(DeprecatedString a_name, bool a_is_mutable, utility::Span a_span, types::TypeId a_type_id) :name(move(a_name)), is_mutable(move(a_is_mutable)), span(move(a_span)), type_id(move(a_type_id)){}
 
-(((*this).params) = changed_params);
+ErrorOr<DeprecatedString> types::FunctionGenericParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("FunctionGenericParameter("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("kind: {}, ", kind));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("checked_parameter: {}", checked_parameter));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<types::FunctionGenericParameter> types::FunctionGenericParameter::parameter(types::TypeId const type_id,utility::Span const span) {
+{
+return (types::FunctionGenericParameter( types::FunctionGenericParameterKind { typename types::FunctionGenericParameterKind::Parameter() } ,TRY((types::CheckedGenericParameter::make(type_id,span)))));
 }
-return {};
 }
 
-bool types::CheckedFunction::is_mutating() const {
+types::TypeId types::FunctionGenericParameter::type_id() const {
 {
-if ((((((*this).params)).size()) < static_cast<size_t>(1ULL))){
-return (false);
-}
-NonnullRefPtr<types::CheckedVariable> const first_param_variable = ((((((*this).params))[static_cast<i64>(0LL)])).variable);
-return (((((first_param_variable)->name) == Jakt::DeprecatedString("this"sv)) && ((first_param_variable)->is_mutable)));
+return (((((*this).checked_parameter)).type_id));
 }
 }
 
-DeprecatedString types::CheckedFunction::name_for_codegen() const {
-{
-return (((*this).external_name).value_or_lazy_evaluated([&] { return ((*this).name); }));
+types::FunctionGenericParameter::FunctionGenericParameter(types::FunctionGenericParameterKind a_kind, types::CheckedGenericParameter a_checked_parameter) :kind(move(a_kind)), checked_parameter(move(a_checked_parameter)){}
+
+ErrorOr<DeprecatedString> types::CheckedNamespace::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedNamespace("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scope: {}", scope));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::CheckedNamespace::CheckedNamespace(DeprecatedString a_name, types::ScopeId a_scope) :name(move(a_name)), scope(move(a_scope)){}
+
+ErrorOr<DeprecatedString> types::CheckedField::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedField("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("variable_id: {}, ", variable_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("default_value: {}, ", default_value));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("default_value_expression: {}", default_value_expression));
 }
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::CheckedField::CheckedField(types::VarId a_variable_id, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> a_default_value, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_value_expression) :variable_id(move(a_variable_id)), default_value(move(a_default_value)), default_value_expression(move(a_default_value_expression)){}
 
-ErrorOr<void> types::CheckedFunction::set_params(JaktInternal::DynamicArray<types::CheckedParameter> const checked_params) {
+ErrorOr<DeprecatedString> types::CheckedGenericParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedGenericParameter("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}, ", type_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("constraints: {}, ", constraints));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+ErrorOr<types::CheckedGenericParameter> types::CheckedGenericParameter::make(types::TypeId const type_id,utility::Span const span) {
 {
-(((*this).params) = checked_params);
-(((((*this).generics))->base_params) = checked_params);
+return (types::CheckedGenericParameter(type_id,(TRY((DynamicArray<types::TraitId>::create_with({})))),span));
 }
-return {};
 }
-
-ErrorOr<DeprecatedString> types::EnumId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("EnumId("sv));{
+
+types::CheckedGenericParameter::CheckedGenericParameter(types::TypeId a_type_id, JaktInternal::DynamicArray<types::TraitId> a_constraints, utility::Span a_span) :type_id(move(a_type_id)), constraints(move(a_constraints)), span(move(a_span)){}
+
+ErrorOr<DeprecatedString> types::Scope::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Scope("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespace_name: {}, ", namespace_name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}, ", external_name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("vars: {}, ", vars));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("comptime_bindings: {}, ", comptime_bindings));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("structs: {}, ", structs));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("functions: {}, ", functions));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("enums: {}, ", enums));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("types: {}, ", types));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("imports: {}, ", imports));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("aliases: {}, ", aliases));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parent: {}, ", parent));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("alias_scope: {}, ", alias_scope));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("children: {}, ", children));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("can_throw: {}, ", can_throw));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("import_path_if_extern: {}, ", import_path_if_extern));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("alias_path: {}, ", alias_path));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("after_extern_include: {}, ", after_extern_include));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("before_extern_include: {}, ", before_extern_include));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("debug_name: \"{}\", ", debug_name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("resolution_mixins: {}, ", resolution_mixins));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_block_scope: {}", is_block_scope));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::Scope::Scope(JaktInternal::Optional<DeprecatedString> a_namespace_name, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Dictionary<DeprecatedString,types::VarId> a_vars, JaktInternal::Dictionary<DeprecatedString,types::Value> a_comptime_bindings, JaktInternal::Dictionary<DeprecatedString,types::StructId> a_structs, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> a_functions, JaktInternal::Dictionary<DeprecatedString,types::EnumId> a_enums, JaktInternal::Dictionary<DeprecatedString,types::TypeId> a_types, JaktInternal::Dictionary<DeprecatedString,types::TraitId> a_traits, JaktInternal::Dictionary<DeprecatedString,types::ModuleId> a_imports, JaktInternal::Dictionary<DeprecatedString,types::ScopeId> a_aliases, JaktInternal::Optional<types::ScopeId> a_parent, JaktInternal::Optional<types::ScopeId> a_alias_scope, JaktInternal::DynamicArray<types::ScopeId> a_children, bool a_can_throw, JaktInternal::Optional<DeprecatedString> a_import_path_if_extern, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> a_alias_path, JaktInternal::DynamicArray<parser::IncludeAction> a_after_extern_include, JaktInternal::DynamicArray<parser::IncludeAction> a_before_extern_include, DeprecatedString a_debug_name, JaktInternal::DynamicArray<types::ScopeId> a_resolution_mixins, bool a_is_block_scope): namespace_name(move(a_namespace_name)), external_name(move(a_external_name)), vars(move(a_vars)), comptime_bindings(move(a_comptime_bindings)), structs(move(a_structs)), functions(move(a_functions)), enums(move(a_enums)), types(move(a_types)), traits(move(a_traits)), imports(move(a_imports)), aliases(move(a_aliases)), parent(move(a_parent)), alias_scope(move(a_alias_scope)), children(move(a_children)), can_throw(move(a_can_throw)), import_path_if_extern(move(a_import_path_if_extern)), alias_path(move(a_alias_path)), after_extern_include(move(a_after_extern_include)), before_extern_include(move(a_before_extern_include)), debug_name(move(a_debug_name)), resolution_mixins(move(a_resolution_mixins)), is_block_scope(move(a_is_block_scope)){}
+ErrorOr<NonnullRefPtr<Scope>> types::Scope::__jakt_create(JaktInternal::Optional<DeprecatedString> namespace_name, JaktInternal::Optional<DeprecatedString> external_name, JaktInternal::Dictionary<DeprecatedString,types::VarId> vars, JaktInternal::Dictionary<DeprecatedString,types::Value> comptime_bindings, JaktInternal::Dictionary<DeprecatedString,types::StructId> structs, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> functions, JaktInternal::Dictionary<DeprecatedString,types::EnumId> enums, JaktInternal::Dictionary<DeprecatedString,types::TypeId> types, JaktInternal::Dictionary<DeprecatedString,types::TraitId> traits, JaktInternal::Dictionary<DeprecatedString,types::ModuleId> imports, JaktInternal::Dictionary<DeprecatedString,types::ScopeId> aliases, JaktInternal::Optional<types::ScopeId> parent, JaktInternal::Optional<types::ScopeId> alias_scope, JaktInternal::DynamicArray<types::ScopeId> children, bool can_throw, JaktInternal::Optional<DeprecatedString> import_path_if_extern, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> alias_path, JaktInternal::DynamicArray<parser::IncludeAction> after_extern_include, JaktInternal::DynamicArray<parser::IncludeAction> before_extern_include, DeprecatedString debug_name, JaktInternal::DynamicArray<types::ScopeId> resolution_mixins, bool is_block_scope) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Scope (move(namespace_name), move(external_name), move(vars), move(comptime_bindings), move(structs), move(functions), move(enums), move(types), move(traits), move(imports), move(aliases), move(parent), move(alias_scope), move(children), move(can_throw), move(import_path_if_extern), move(alias_path), move(after_extern_include), move(before_extern_include), move(debug_name), move(resolution_mixins), move(is_block_scope)))); return o; }
+ErrorOr<DeprecatedString> types::TypeId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("TypeId("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-bool types::EnumId::equals(types::EnumId const rhs) const {
+ErrorOr<DeprecatedString> types::TypeId::to_string() const {
 {
-return (((((((*this).module)).id) == ((((rhs).module)).id)) && (((*this).id) == ((rhs).id))));
+return (TRY((__jakt_format(Jakt::DeprecatedString("{}_{}"sv),((((*this).module)).id),((*this).id)))));
 }
 }
 
-types::EnumId::EnumId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
-
-ErrorOr<DeprecatedString> types::StructId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("StructId("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-bool types::StructId::equals(types::StructId const rhs) const {
+JaktInternal::Optional<types::TypeId> types::TypeId::none() {
 {
-return (((((((*this).module)).id) == ((((rhs).module)).id)) && (((*this).id) == ((rhs).id))));
+return (JaktInternal::OptionalNone());
 }
 }
 
-types::StructId::StructId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
+types::TypeId::TypeId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
 
-ErrorOr<DeprecatedString> types::ScopeId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ScopeId("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module_id: {}, ", module_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<DeprecatedString> types::ScopeId::to_string() const {
+bool types::TypeId::equals(types::TypeId const rhs) const {
 {
-return (TRY((__jakt_format(Jakt::DeprecatedString("{}:{}"sv),((((*this).module_id)).id),((*this).id)))));
+return (((((((*this).module)).id) == ((((rhs).module)).id)) && (((*this).id) == ((rhs).id))));
 }
 }
 
-bool types::ScopeId::equals(types::ScopeId const other) const {
+ErrorOr<types::TypeId> types::TypeId::from_string(DeprecatedString const type_id_string) {
 {
-return (((((((*this).module_id)).id) == ((((other).module_id)).id)) && (((*this).id) == ((other).id))));
+JaktInternal::DynamicArray<DeprecatedString> const parts = ((type_id_string).split('_'));
+if ((!((((parts).size()) == static_cast<size_t>(2ULL))))){
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Failed to convert string ‘{}’ to a TypeId: Wrong number of parts. (Wanted 2, got {})"sv),type_id_string,((parts).size())))));
+}
+JaktInternal::Optional<u32> const module_id = ((((parts)[static_cast<i64>(0LL)])).to_uint());
+JaktInternal::Optional<u32> const type_id = ((((parts)[static_cast<i64>(1LL)])).to_uint());
+if (((!(((module_id).has_value()))) || (!(((type_id).has_value()))))){
+utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Failed to convert string ‘{}’ to a TypeId. (module_id = {} ({}), type_id = {} ({}))"sv),type_id_string,module_id,((parts)[static_cast<i64>(0LL)]),type_id,((parts)[static_cast<i64>(1LL)])))));
+}
+return (types::TypeId(types::ModuleId((infallible_integer_cast<size_t>((((module_id).value()))))),(infallible_integer_cast<size_t>((((type_id).value()))))));
 }
 }
 
-types::ScopeId::ScopeId(types::ModuleId a_module_id, size_t a_id) :module_id(move(a_module_id)), id(move(a_id)){}
-
-ErrorOr<DeprecatedString> types::LoadedModule::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("LoadedModule("sv));{
+ErrorOr<DeprecatedString> types::FieldRecord::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("FieldRecord("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module_id: {}, ", module_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("file_id: {}", file_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("struct_id: {}, ", struct_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("field_id: {}", field_id));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-types::LoadedModule::LoadedModule(types::ModuleId a_module_id, utility::FileId a_file_id) :module_id(move(a_module_id)), file_id(move(a_file_id)){}
+types::FieldRecord::FieldRecord(types::StructId a_struct_id, types::VarId a_field_id) :struct_id(move(a_struct_id)), field_id(move(a_field_id)){}
 
 ErrorOr<DeprecatedString> types::CheckedEnum::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedEnum("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
@@ -2255,144 +2253,216 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff
 TRY(builder.append(")"sv));return builder.to_string(); }
 types::CheckedEnum::CheckedEnum(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<types::CheckedEnumVariant> a_variants, JaktInternal::DynamicArray<types::CheckedField> a_fields, types::ScopeId a_scope_id, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> a_trait_implementations, parser::RecordType a_record_type, types::TypeId a_underlying_type_id, types::TypeId a_type_id, bool a_is_boxed) :name(move(a_name)), name_span(move(a_name_span)), generic_parameters(move(a_generic_parameters)), variants(move(a_variants)), fields(move(a_fields)), scope_id(move(a_scope_id)), definition_linkage(move(a_definition_linkage)), trait_implementations(move(a_trait_implementations)), record_type(move(a_record_type)), underlying_type_id(move(a_underlying_type_id)), type_id(move(a_type_id)), is_boxed(move(a_is_boxed)){}
 
-ErrorOr<DeprecatedString> types::FunctionGenericParameter::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("FunctionGenericParameter("sv));{
+ErrorOr<DeprecatedString> types::CheckedBlock::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedBlock("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("kind: {}, ", kind));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("checked_parameter: {}", checked_parameter));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("statements: {}, ", statements));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scope_id: {}, ", scope_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("control_flow: {}, ", control_flow));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("yielded_type: {}, ", yielded_type));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("yielded_none: {}", yielded_none));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<types::FunctionGenericParameter> types::FunctionGenericParameter::parameter(types::TypeId const type_id,utility::Span const span) {
-{
-return (types::FunctionGenericParameter( types::FunctionGenericParameterKind { typename types::FunctionGenericParameterKind::Parameter() } ,TRY((types::CheckedGenericParameter::make(type_id,span)))));
-}
-}
+types::CheckedBlock::CheckedBlock(JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> a_statements, types::ScopeId a_scope_id, types::BlockControlFlow a_control_flow, JaktInternal::Optional<types::TypeId> a_yielded_type, bool a_yielded_none) :statements(move(a_statements)), scope_id(move(a_scope_id)), control_flow(move(a_control_flow)), yielded_type(move(a_yielded_type)), yielded_none(move(a_yielded_none)){}
 
-types::TypeId types::FunctionGenericParameter::type_id() const {
+ErrorOr<DeprecatedString> types::TraitId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("TraitId("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+bool types::TraitId::equals(types::TraitId const other) const {
 {
-return (((((*this).checked_parameter)).type_id));
+return (((((((*this).module)).id) == ((((other).module)).id)) && (((*this).id) == ((other).id))));
 }
 }
 
-types::FunctionGenericParameter::FunctionGenericParameter(types::FunctionGenericParameterKind a_kind, types::CheckedGenericParameter a_checked_parameter) :kind(move(a_kind)), checked_parameter(move(a_checked_parameter)){}
+types::TraitId::TraitId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
 
-ErrorOr<DeprecatedString> types::ResolvedNamespace::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ResolvedNamespace("sv));{
+ErrorOr<DeprecatedString> types::FunctionId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("FunctionId("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}, ", external_name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("generic_parameters: {}", generic_parameters));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-types::ResolvedNamespace::ResolvedNamespace(DeprecatedString a_name, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> a_generic_parameters) :name(move(a_name)), external_name(move(a_external_name)), generic_parameters(move(a_generic_parameters)){}
+types::FunctionId::FunctionId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
 
-ErrorOr<DeprecatedString> types::Scope::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Scope("sv));{
+bool types::FunctionId::equals(types::FunctionId const rhs) const {
+{
+return (((((((*this).module)).id) == ((((rhs).module)).id)) && (((*this).id) == ((rhs).id))));
+}
+}
+
+ErrorOr<DeprecatedString> types::Module::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("Module("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("namespace_name: {}, ", namespace_name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("external_name: {}, ", external_name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("vars: {}, ", vars));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("comptime_bindings: {}, ", comptime_bindings));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("structs: {}, ", structs));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}, ", id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: \"{}\", ", name));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("functions: {}, ", functions));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("structures: {}, ", structures));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("enums: {}, ", enums));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("scopes: {}, ", scopes));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("types: {}, ", types));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("traits: {}, ", traits));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("variables: {}, ", variables));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("imports: {}, ", imports));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("aliases: {}, ", aliases));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("parent: {}, ", parent));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("alias_scope: {}, ", alias_scope));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("children: {}, ", children));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("can_throw: {}, ", can_throw));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("import_path_if_extern: {}, ", import_path_if_extern));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("alias_path: {}, ", alias_path));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("after_extern_include: {}, ", after_extern_include));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("before_extern_include: {}, ", before_extern_include));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("debug_name: \"{}\", ", debug_name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("resolution_mixins: {}, ", resolution_mixins));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_block_scope: {}", is_block_scope));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("resolved_import_path: \"{}\", ", resolved_import_path));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("is_root: {}", is_root));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-types::Scope::Scope(JaktInternal::Optional<DeprecatedString> a_namespace_name, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Dictionary<DeprecatedString,types::VarId> a_vars, JaktInternal::Dictionary<DeprecatedString,types::Value> a_comptime_bindings, JaktInternal::Dictionary<DeprecatedString,types::StructId> a_structs, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> a_functions, JaktInternal::Dictionary<DeprecatedString,types::EnumId> a_enums, JaktInternal::Dictionary<DeprecatedString,types::TypeId> a_types, JaktInternal::Dictionary<DeprecatedString,types::TraitId> a_traits, JaktInternal::Dictionary<DeprecatedString,types::ModuleId> a_imports, JaktInternal::Dictionary<DeprecatedString,types::ScopeId> a_aliases, JaktInternal::Optional<types::ScopeId> a_parent, JaktInternal::Optional<types::ScopeId> a_alias_scope, JaktInternal::DynamicArray<types::ScopeId> a_children, bool a_can_throw, JaktInternal::Optional<DeprecatedString> a_import_path_if_extern, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> a_alias_path, JaktInternal::DynamicArray<parser::IncludeAction> a_after_extern_include, JaktInternal::DynamicArray<parser::IncludeAction> a_before_extern_include, DeprecatedString a_debug_name, JaktInternal::DynamicArray<types::ScopeId> a_resolution_mixins, bool a_is_block_scope): namespace_name(move(a_namespace_name)), external_name(move(a_external_name)), vars(move(a_vars)), comptime_bindings(move(a_comptime_bindings)), structs(move(a_structs)), functions(move(a_functions)), enums(move(a_enums)), types(move(a_types)), traits(move(a_traits)), imports(move(a_imports)), aliases(move(a_aliases)), parent(move(a_parent)), alias_scope(move(a_alias_scope)), children(move(a_children)), can_throw(move(a_can_throw)), import_path_if_extern(move(a_import_path_if_extern)), alias_path(move(a_alias_path)), after_extern_include(move(a_after_extern_include)), before_extern_include(move(a_before_extern_include)), debug_name(move(a_debug_name)), resolution_mixins(move(a_resolution_mixins)), is_block_scope(move(a_is_block_scope)){}
-ErrorOr<NonnullRefPtr<Scope>> types::Scope::__jakt_create(JaktInternal::Optional<DeprecatedString> namespace_name, JaktInternal::Optional<DeprecatedString> external_name, JaktInternal::Dictionary<DeprecatedString,types::VarId> vars, JaktInternal::Dictionary<DeprecatedString,types::Value> comptime_bindings, JaktInternal::Dictionary<DeprecatedString,types::StructId> structs, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> functions, JaktInternal::Dictionary<DeprecatedString,types::EnumId> enums, JaktInternal::Dictionary<DeprecatedString,types::TypeId> types, JaktInternal::Dictionary<DeprecatedString,types::TraitId> traits, JaktInternal::Dictionary<DeprecatedString,types::ModuleId> imports, JaktInternal::Dictionary<DeprecatedString,types::ScopeId> aliases, JaktInternal::Optional<types::ScopeId> parent, JaktInternal::Optional<types::ScopeId> alias_scope, JaktInternal::DynamicArray<types::ScopeId> children, bool can_throw, JaktInternal::Optional<DeprecatedString> import_path_if_extern, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> alias_path, JaktInternal::DynamicArray<parser::IncludeAction> after_extern_include, JaktInternal::DynamicArray<parser::IncludeAction> before_extern_include, DeprecatedString debug_name, JaktInternal::DynamicArray<types::ScopeId> resolution_mixins, bool is_block_scope) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Scope (move(namespace_name), move(external_name), move(vars), move(comptime_bindings), move(structs), move(functions), move(enums), move(types), move(traits), move(imports), move(aliases), move(parent), move(alias_scope), move(children), move(can_throw), move(import_path_if_extern), move(alias_path), move(after_extern_include), move(before_extern_include), move(debug_name), move(resolution_mixins), move(is_block_scope)))); return o; }
-ErrorOr<DeprecatedString> types::TypeId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("TypeId("sv));{
+types::FunctionId types::Module::next_function_id() const {
+{
+return (types::FunctionId(((*this).id),((((*this).functions)).size())));
+}
+}
+
+ErrorOr<types::FunctionId> types::Module::add_function(NonnullRefPtr<types::CheckedFunction> const checked_function) {
+{
+types::FunctionId const new_id = ((*this).next_function_id());
+TRY((((((*this).functions)).push(checked_function))));
+return (new_id);
+}
+}
+
+bool types::Module::is_prelude() const {
+{
+return ((((((*this).id)).id) == static_cast<size_t>(0ULL)));
+}
+}
+
+types::Module::Module(types::ModuleId a_id, DeprecatedString a_name, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> a_functions, JaktInternal::DynamicArray<types::CheckedStruct> a_structures, JaktInternal::DynamicArray<types::CheckedEnum> a_enums, JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> a_scopes, JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> a_types, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> a_traits, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> a_variables, JaktInternal::DynamicArray<types::ModuleId> a_imports, DeprecatedString a_resolved_import_path, bool a_is_root): id(move(a_id)), name(move(a_name)), functions(move(a_functions)), structures(move(a_structures)), enums(move(a_enums)), scopes(move(a_scopes)), types(move(a_types)), traits(move(a_traits)), variables(move(a_variables)), imports(move(a_imports)), resolved_import_path(move(a_resolved_import_path)), is_root(move(a_is_root)){}
+ErrorOr<NonnullRefPtr<Module>> types::Module::__jakt_create(types::ModuleId id, DeprecatedString name, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> functions, JaktInternal::DynamicArray<types::CheckedStruct> structures, JaktInternal::DynamicArray<types::CheckedEnum> enums, JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> scopes, JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> types, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> traits, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> variables, JaktInternal::DynamicArray<types::ModuleId> imports, DeprecatedString resolved_import_path, bool is_root) { auto o = TRY(adopt_nonnull_ref_or_enomem(new (nothrow) Module (move(id), move(name), move(functions), move(structures), move(enums), move(scopes), move(types), move(traits), move(variables), move(imports), move(resolved_import_path), move(is_root)))); return o; }
+ErrorOr<types::VarId> types::Module::add_variable(NonnullRefPtr<types::CheckedVariable> const checked_variable) {
+{
+size_t const new_id = ((((*this).variables)).size());
+TRY((((((*this).variables)).push(checked_variable))));
+return (types::VarId(((*this).id),new_id));
+}
+}
+
+ErrorOr<types::TypeId> types::Module::new_type_variable(JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const implemented_traits) {
+{
+size_t const new_id = ((((*this).types)).size());
+JaktInternal::DynamicArray<types::TypeId> const empty_implementation = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+JaktInternal::DynamicArray<types::TypeId> const trait_implementations = implemented_traits.value_or_lazy_evaluated([&] { return empty_implementation; });
+TRY((((((*this).types)).push(TRY((types::Type::template __jakt_create<typename types::Type::TypeVariable>(TRY((__jakt_format(Jakt::DeprecatedString("T{}"sv),new_id))),trait_implementations)))))));
+return (types::TypeId(((*this).id),new_id));
+}
+}
+
+ErrorOr<DeprecatedString> types::VarId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("VarId("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
-ErrorOr<DeprecatedString> types::TypeId::to_string() const {
-{
-return (TRY((__jakt_format(Jakt::DeprecatedString("{}_{}"sv),((((*this).module)).id),((*this).id)))));
-}
-}
+types::VarId::VarId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
 
-JaktInternal::Optional<types::TypeId> types::TypeId::none() {
+ErrorOr<DeprecatedString> types::ModuleId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ModuleId("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+bool types::ModuleId::equals(types::ModuleId const rhs) const {
 {
-return (JaktInternal::OptionalNone());
+return ((((*this).id) == ((rhs).id)));
 }
 }
 
-bool types::TypeId::equals(types::TypeId const rhs) const {
+types::ModuleId::ModuleId(size_t a_id) :id(move(a_id)){}
+
+ErrorOr<DeprecatedString> types::EnumId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("EnumId("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("module: {}, ", module));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+bool types::EnumId::equals(types::EnumId const rhs) const {
 {
 return (((((((*this).module)).id) == ((((rhs).module)).id)) && (((*this).id) == ((rhs).id))));
 }
 }
 
-types::TypeId::TypeId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
+types::EnumId::EnumId(types::ModuleId a_module, size_t a_id) :module(move(a_module)), id(move(a_id)){}
 
-ErrorOr<types::TypeId> types::TypeId::from_string(DeprecatedString const type_id_string) {
+ErrorOr<DeprecatedString> types::CheckedEnumVariantBinding::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedEnumVariantBinding("sv));{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: {}, ", name));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("binding: \"{}\", ", binding));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}, ", type_id));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
+}
+TRY(builder.append(")"sv));return builder.to_string(); }
+types::CheckedEnumVariantBinding::CheckedEnumVariantBinding(JaktInternal::Optional<DeprecatedString> a_name, DeprecatedString a_binding, types::TypeId a_type_id, utility::Span a_span) :name(move(a_name)), binding(move(a_binding)), type_id(move(a_type_id)), span(move(a_span)){}
+
+ErrorOr<DeprecatedString> types::CheckedUnaryOperator::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* PreIncrement */: {
+return DeprecatedString("CheckedUnaryOperator::PreIncrement"sv);
+break;}
+case 1 /* PostIncrement */: {
+return DeprecatedString("CheckedUnaryOperator::PostIncrement"sv);
+break;}
+case 2 /* PreDecrement */: {
+return DeprecatedString("CheckedUnaryOperator::PreDecrement"sv);
+break;}
+case 3 /* PostDecrement */: {
+return DeprecatedString("CheckedUnaryOperator::PostDecrement"sv);
+break;}
+case 4 /* Negate */: {
+return DeprecatedString("CheckedUnaryOperator::Negate"sv);
+break;}
+case 5 /* Dereference */: {
+return DeprecatedString("CheckedUnaryOperator::Dereference"sv);
+break;}
+case 6 /* RawAddress */: {
+return DeprecatedString("CheckedUnaryOperator::RawAddress"sv);
+break;}
+case 7 /* Reference */: {
+return DeprecatedString("CheckedUnaryOperator::Reference"sv);
+break;}
+case 8 /* MutableReference */: {
+return DeprecatedString("CheckedUnaryOperator::MutableReference"sv);
+break;}
+case 9 /* LogicalNot */: {
+return DeprecatedString("CheckedUnaryOperator::LogicalNot"sv);
+break;}
+case 10 /* BitwiseNot */: {
+return DeprecatedString("CheckedUnaryOperator::BitwiseNot"sv);
+break;}
+case 11 /* TypeCast */: {
+TRY(builder.append("CheckedUnaryOperator::TypeCast"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedUnaryOperator::TypeCast>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 12 /* Is */: {
+TRY(builder.append("CheckedUnaryOperator::Is"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedUnaryOperator::Is>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 13 /* IsEnumVariant */: {
+TRY(builder.append("CheckedUnaryOperator::IsEnumVariant"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedUnaryOperator::IsEnumVariant>();
+TRY(builder.append("("sv));
 {
-JaktInternal::DynamicArray<DeprecatedString> const parts = ((type_id_string).split('_'));
-if ((!((((parts).size()) == static_cast<size_t>(2ULL))))){
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Failed to convert string ‘{}’ to a TypeId: Wrong number of parts. (Wanted 2, got {})"sv),type_id_string,((parts).size())))));
-}
-JaktInternal::Optional<u32> const module_id = ((((parts)[static_cast<i64>(0LL)])).to_uint());
-JaktInternal::Optional<u32> const type_id = ((((parts)[static_cast<i64>(1LL)])).to_uint());
-if (((!(((module_id).has_value()))) || (!(((type_id).has_value()))))){
-utility::panic(TRY((__jakt_format(Jakt::DeprecatedString("Failed to convert string ‘{}’ to a TypeId. (module_id = {} ({}), type_id = {} ({}))"sv),type_id_string,module_id,((parts)[static_cast<i64>(0LL)]),type_id,((parts)[static_cast<i64>(1LL)])))));
-}
-return (types::TypeId(types::ModuleId((infallible_integer_cast<size_t>((((module_id).value()))))),(infallible_integer_cast<size_t>((((type_id).value()))))));
-}
-}
-
-ErrorOr<DeprecatedString> types::FieldRecord::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("FieldRecord("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("struct_id: {}, ", struct_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("field_id: {}", field_id));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::FieldRecord::FieldRecord(types::StructId a_struct_id, types::VarId a_field_id) :struct_id(move(a_struct_id)), field_id(move(a_field_id)){}
-
-ErrorOr<DeprecatedString> types::ModuleId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("ModuleId("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
-}
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::ModuleId::ModuleId(size_t a_id) :id(move(a_id)){}
-
-bool types::ModuleId::equals(types::ModuleId const rhs) const {
-{
-return ((((*this).id) == ((rhs).id)));
-}
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("enum_variant: {}", that.enum_variant));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("bindings: {}", that.bindings));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
-
-ErrorOr<DeprecatedString> types::CheckedEnumVariantBinding::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedEnumVariantBinding("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("name: {}, ", name));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("binding: \"{}\", ", binding));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("type_id: {}, ", type_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("span: {}", span));
+TRY(builder.append(")"sv));
+break;}
+case 14 /* Sizeof */: {
+TRY(builder.append("CheckedUnaryOperator::Sizeof"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedUnaryOperator::Sizeof>();
+TRY(builder.appendff("({})", that.value));
+break;}
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedEnumVariantBinding::CheckedEnumVariantBinding(JaktInternal::Optional<DeprecatedString> a_name, DeprecatedString a_binding, types::TypeId a_type_id, utility::Span a_span) :name(move(a_name)), binding(move(a_binding)), type_id(move(a_type_id)), span(move(a_span)){}
-
-ErrorOr<DeprecatedString> types::CheckedField::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("CheckedField("sv));{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("variable_id: {}, ", variable_id));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("default_value: {}, ", default_value));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("default_value_expression: {}", default_value_expression));
+return builder.to_string();
 }
-TRY(builder.append(")"sv));return builder.to_string(); }
-types::CheckedField::CheckedField(types::VarId a_variable_id, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> a_default_value, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_value_expression) :variable_id(move(a_variable_id)), default_value(move(a_default_value)), default_value_expression(move(a_default_value_expression)){}
-
 ErrorOr<DeprecatedString> types::NumericOrStringValue::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
 switch (this->index()) {case 0 /* StringValue */: {
@@ -2606,248 +2676,121 @@ break;}
 }
 return builder.to_string();
 }
-bool types::Type::equals(NonnullRefPtr<typename types::Type> const rhs) const {
+u64 types::Type::max() const {
 {
-if ((((*this).index() == 0 /* Void */) && ((rhs)->index() == 0 /* Void */))){
-return (true);
-}
-else if ((((*this).index() == 1 /* Bool */) && ((rhs)->index() == 1 /* Bool */))){
-return (true);
-}
-else if ((((*this).index() == 2 /* U8 */) && ((rhs)->index() == 2 /* U8 */))){
-return (true);
-}
-else if ((((*this).index() == 3 /* U16 */) && ((rhs)->index() == 3 /* U16 */))){
-return (true);
-}
-else if ((((*this).index() == 4 /* U32 */) && ((rhs)->index() == 4 /* U32 */))){
-return (true);
-}
-else if ((((*this).index() == 5 /* U64 */) && ((rhs)->index() == 5 /* U64 */))){
-return (true);
-}
-else if ((((*this).index() == 6 /* I8 */) && ((rhs)->index() == 6 /* I8 */))){
-return (true);
-}
-else if ((((*this).index() == 7 /* I16 */) && ((rhs)->index() == 7 /* I16 */))){
-return (true);
-}
-else if ((((*this).index() == 8 /* I32 */) && ((rhs)->index() == 8 /* I32 */))){
-return (true);
-}
-else if ((((*this).index() == 9 /* I64 */) && ((rhs)->index() == 9 /* I64 */))){
-return (true);
-}
-else if ((((*this).index() == 10 /* F32 */) && ((rhs)->index() == 10 /* F32 */))){
-return (true);
-}
-else if ((((*this).index() == 11 /* F64 */) && ((rhs)->index() == 11 /* F64 */))){
-return (true);
-}
-else if ((((*this).index() == 12 /* Usize */) && ((rhs)->index() == 12 /* Usize */))){
-return (true);
-}
-else if ((((*this).index() == 13 /* JaktString */) && ((rhs)->index() == 13 /* JaktString */))){
-return (true);
-}
-else if ((((*this).index() == 14 /* CChar */) && ((rhs)->index() == 14 /* CChar */))){
-return (true);
-}
-else if ((((*this).index() == 15 /* CInt */) && ((rhs)->index() == 15 /* CInt */))){
-return (true);
-}
-else if ((((*this).index() == 30 /* Self */) && ((rhs)->index() == 30 /* Self */))){
-return (true);
-}
-else if ((((*this).index() == 16 /* Unknown */) && ((rhs)->index() == 16 /* Unknown */))){
-return (true);
-}
-else if ((((*this).index() == 17 /* Never */) && ((rhs)->index() == 17 /* Never */))){
-return (true);
-}
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, bool>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, u64>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::TypeVariable>();DeprecatedString const& lhs_name = __jakt_match_value.name;
-{
-if (((rhs)->index() == 18 /* TypeVariable */)){
-DeprecatedString const rhs_name = ((rhs)->get<types::Type::TypeVariable>()).name;
-return ((lhs_name == rhs_name));
-}
-else {
-return (false);
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
+case 14: {
+return JaktInternal::ExplicitValue(static_cast<u64>(127ULL));
 };/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& lhs_id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& lhs_args = __jakt_match_value.args;
-{
-if (((rhs)->index() == 19 /* GenericInstance */)){
-types::StructId const rhs_id = ((rhs)->get<types::Type::GenericInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const rhs_args = ((rhs)->get<types::Type::GenericInstance>()).args;
-if ((((lhs_id).equals(rhs_id)) && (((lhs_args).size()) == ((rhs_args).size())))){
-size_t idx = static_cast<size_t>(0ULL);
-while ((idx < ((lhs_args).size()))){
-if ((!(((((lhs_args)[idx])).equals(((rhs_args)[idx])))))){
-return (false);
-}
-((idx++));
-}
-return (true);
-}
-else {
-return (false);
-}
-
-}
-else {
-return (false);
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
+case 15: {
+return JaktInternal::ExplicitValue(static_cast<u64>(2147483647ULL));
 };/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& lhs_id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& lhs_args = __jakt_match_value.args;
-{
-if (((rhs)->index() == 21 /* GenericTraitInstance */)){
-types::TraitId const rhs_id = ((rhs)->get<types::Type::GenericTraitInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const rhs_args = ((rhs)->get<types::Type::GenericTraitInstance>()).args;
-if ((((lhs_id).equals(rhs_id)) && (((lhs_args).size()) == ((rhs_args).size())))){
-size_t idx = static_cast<size_t>(0ULL);
-while ((idx < ((lhs_args).size()))){
-if ((!(((((lhs_args)[idx])).equals(((rhs_args)[idx])))))){
-return (false);
-}
-((idx++));
-}
-return (true);
-}
-else {
-return (false);
-}
-
+case 6: {
+return JaktInternal::ExplicitValue(static_cast<u64>(127ULL));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(static_cast<u64>(32767ULL));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(static_cast<u64>(2147483647ULL));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(static_cast<u64>(9223372036854775807ULL));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(static_cast<u64>(255ULL));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(static_cast<u64>(65535ULL));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(static_cast<u64>(4294967295ULL));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(static_cast<u64>(18446744073709551615ULL));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(static_cast<u64>(18446744073709551615ULL));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(static_cast<u64>(0ULL));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
-else {
-return (false);
 }
 
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& lhs_id = __jakt_match_value.id;
-JaktInternal::DynamicArray<types::TypeId> const& lhs_args = __jakt_match_value.args;
+bool types::Type::equals(NonnullRefPtr<typename types::Type> const rhs) const {
 {
-if (((rhs)->index() == 20 /* GenericEnumInstance */)){
-types::EnumId const rhs_id = ((rhs)->get<types::Type::GenericEnumInstance>()).id;
-JaktInternal::DynamicArray<types::TypeId> const rhs_args = ((rhs)->get<types::Type::GenericEnumInstance>()).args;
-if ((((lhs_id).equals(rhs_id)) && (((lhs_args).size()) == ((rhs_args).size())))){
-size_t idx = static_cast<size_t>(0ULL);
-while ((idx < ((lhs_args).size()))){
-if ((!(((((lhs_args)[idx])).equals(((rhs_args)[idx])))))){
-return (false);
-}
-((idx++));
-}
+if ((((*this).index() == 0 /* Void */) && ((rhs)->index() == 0 /* Void */))){
 return (true);
 }
-else {
-return (false);
+else if ((((*this).index() == 1 /* Bool */) && ((rhs)->index() == 1 /* Bool */))){
+return (true);
 }
-
+else if ((((*this).index() == 2 /* U8 */) && ((rhs)->index() == 2 /* U8 */))){
+return (true);
 }
-else {
-return (false);
+else if ((((*this).index() == 3 /* U16 */) && ((rhs)->index() == 3 /* U16 */))){
+return (true);
 }
-
+else if ((((*this).index() == 4 /* U32 */) && ((rhs)->index() == 4 /* U32 */))){
+return (true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
-types::StructId const& lhs_id = __jakt_match_value.value;
-{
-if (((rhs)->index() == 23 /* Struct */)){
-types::StructId const rhs_id = ((rhs)->get<types::Type::Struct>()).value;
-return (((lhs_id).equals(rhs_id)));
+else if ((((*this).index() == 5 /* U64 */) && ((rhs)->index() == 5 /* U64 */))){
+return (true);
 }
-return (false);
+else if ((((*this).index() == 6 /* I8 */) && ((rhs)->index() == 6 /* I8 */))){
+return (true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
-types::EnumId const& lhs_id = __jakt_match_value.value;
-{
-if (((rhs)->index() == 24 /* Enum */)){
-types::EnumId const rhs_id = ((rhs)->get<types::Type::Enum>()).value;
-return (((lhs_id).equals(rhs_id)));
+else if ((((*this).index() == 7 /* I16 */) && ((rhs)->index() == 7 /* I16 */))){
+return (true);
 }
-else {
-return (false);
+else if ((((*this).index() == 8 /* I32 */) && ((rhs)->index() == 8 /* I32 */))){
+return (true);
 }
-
+else if ((((*this).index() == 9 /* I64 */) && ((rhs)->index() == 9 /* I64 */))){
+return (true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
-types::TypeId const& lhs_id = __jakt_match_value.value;
-{
-if (((rhs)->index() == 25 /* RawPtr */)){
-types::TypeId const rhs_id = ((rhs)->get<types::Type::RawPtr>()).value;
-return (((lhs_id).equals(rhs_id)));
+else if ((((*this).index() == 10 /* F32 */) && ((rhs)->index() == 10 /* F32 */))){
+return (true);
 }
-else {
-return (false);
+else if ((((*this).index() == 11 /* F64 */) && ((rhs)->index() == 11 /* F64 */))){
+return (true);
 }
-
+else if ((((*this).index() == 12 /* Usize */) && ((rhs)->index() == 12 /* Usize */))){
+return (true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
-types::TypeId const& lhs_id = __jakt_match_value.value;
-{
-if (((rhs)->index() == 27 /* Reference */)){
-types::TypeId const rhs_id = ((rhs)->get<types::Type::Reference>()).value;
-return (((lhs_id).equals(rhs_id)));
+else if ((((*this).index() == 13 /* JaktString */) && ((rhs)->index() == 13 /* JaktString */))){
+return (true);
 }
-else {
-return (false);
+else if ((((*this).index() == 14 /* CChar */) && ((rhs)->index() == 14 /* CChar */))){
+return (true);
 }
-
+else if ((((*this).index() == 15 /* CInt */) && ((rhs)->index() == 15 /* CInt */))){
+return (true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
-types::TypeId const& lhs_id = __jakt_match_value.value;
-{
-if (((rhs)->index() == 28 /* MutableReference */)){
-types::TypeId const rhs_id = ((rhs)->get<types::Type::MutableReference>()).value;
-return (((lhs_id).equals(rhs_id)));
+else if ((((*this).index() == 30 /* Self */) && ((rhs)->index() == 30 /* Self */))){
+return (true);
 }
-else {
-return (false);
+else if ((((*this).index() == 16 /* Unknown */) && ((rhs)->index() == 16 /* Unknown */))){
+return (true);
 }
-
+else if ((((*this).index() == 17 /* Never */) && ((rhs)->index() == 17 /* Never */))){
+return (true);
 }
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
-types::TraitId const& lhs_id = __jakt_match_value.value;
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::TypeVariable>();DeprecatedString const& lhs_name = __jakt_match_value.name;
 {
-if (((rhs)->index() == 26 /* Trait */)){
-types::TraitId const rhs_id = ((rhs)->get<types::Type::Trait>()).value;
-return (((lhs_id).equals(rhs_id)));
+if (((rhs)->index() == 18 /* TypeVariable */)){
+DeprecatedString const rhs_name = ((rhs)->get<types::Type::TypeVariable>()).name;
+return ((lhs_name == rhs_name));
 }
 else {
 return (false);
@@ -2856,33 +2799,21 @@ return (false);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
-bool const& can_throw = __jakt_match_value.can_throw;
-types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
-{
-if (((rhs)->index() == 29 /* Function */)){
-JaktInternal::DynamicArray<types::TypeId> const rhs_params = ((rhs)->get<types::Type::Function>()).params;
-bool const rhs_can_throw = ((rhs)->get<types::Type::Function>()).can_throw;
-types::TypeId const rhs_return_type_id = ((rhs)->get<types::Type::Function>()).return_type_id;
-if (((((params).size()) == ((rhs_params).size())) && (((return_type_id).equals(rhs_return_type_id)) && (can_throw == rhs_can_throw)))){
-{
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((params).size()))});
-for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-size_t i = (_magic_value.value());
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& lhs_id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& lhs_args = __jakt_match_value.args;
 {
-if ((!(((((params)[i])).equals(((rhs_params)[i])))))){
+if (((rhs)->index() == 19 /* GenericInstance */)){
+types::StructId const rhs_id = ((rhs)->get<types::Type::GenericInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const rhs_args = ((rhs)->get<types::Type::GenericInstance>()).args;
+if ((((lhs_id).equals(rhs_id)) && (((lhs_args).size()) == ((rhs_args).size())))){
+size_t idx = static_cast<size_t>(0ULL);
+while ((idx < ((lhs_args).size()))){
+if ((!(((((lhs_args)[idx])).equals(((rhs_args)[idx])))))){
 return (false);
 }
+((idx++));
 }
-
-}
-}
-
 return (true);
 }
 else {
@@ -2897,355 +2828,201 @@ return (false);
 }
 return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-default: {
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericTraitInstance>();types::TraitId const& lhs_id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& lhs_args = __jakt_match_value.args;
 {
-}
-return JaktInternal::ExplicitValue<void>();
-};/*case end*/
-}/*switch end*/
-}()
-));
+if (((rhs)->index() == 21 /* GenericTraitInstance */)){
+types::TraitId const rhs_id = ((rhs)->get<types::Type::GenericTraitInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const rhs_args = ((rhs)->get<types::Type::GenericTraitInstance>()).args;
+if ((((lhs_id).equals(rhs_id)) && (((lhs_args).size()) == ((rhs_args).size())))){
+size_t idx = static_cast<size_t>(0ULL);
+while ((idx < ((lhs_args).size()))){
+if ((!(((((lhs_args)[idx])).equals(((rhs_args)[idx])))))){
 return (false);
 }
+((idx++));
 }
-
-i64 types::Type::get_bits() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue(static_cast<i64>(8LL));
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(static_cast<i64>(8LL));
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(static_cast<i64>(8LL));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(static_cast<i64>(16LL));
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(static_cast<i64>(16LL));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(static_cast<i64>(32LL));
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(static_cast<i64>(32LL));
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(static_cast<i64>(32LL));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(static_cast<i64>(64LL));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(static_cast<i64>(64LL));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(static_cast<i64>(64LL));
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(static_cast<i64>(32LL));
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(static_cast<i64>(64LL));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
-};/*case end*/
-}/*switch end*/
-}()
-)));
-}
-}
-
-i64 types::Type::specificity(NonnullRefPtr<types::CheckedProgram> const program,i64 const base_specificity) const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 18: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<i64> __jakt_var_133; {
-i64 specificity = (JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(2LL)));
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::TypeId subtype_id = (_magic_value.value());
-{
-NonnullRefPtr<typename types::Type> const subtype = ((program)->get_type(subtype_id));
-({auto& _jakt_ref = specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((subtype)->specificity(program,(JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(4LL))))));});
-}
-
-}
-}
-
-__jakt_var_133 = specificity; goto __jakt_label_129;
-
-}
-__jakt_label_129:; __jakt_var_133.release_value(); }));
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<i64> __jakt_var_134; {
-i64 specificity = (JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(2LL)));
-{
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-types::TypeId subtype_id = (_magic_value.value());
-{
-NonnullRefPtr<typename types::Type> const subtype = ((program)->get_type(subtype_id));
-({auto& _jakt_ref = specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((subtype)->specificity(program,(JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(4LL))))));});
+return (true);
+}
+else {
+return (false);
 }
 
 }
+else {
+return (false);
 }
 
-__jakt_var_134 = specificity; goto __jakt_label_130;
-
 }
-__jakt_label_130:; __jakt_var_134.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericResolvedType>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
-return JaktInternal::ExplicitValue(({ Optional<i64> __jakt_var_135; {
-i64 specificity = (JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(2LL)));
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& lhs_id = __jakt_match_value.id;
+JaktInternal::DynamicArray<types::TypeId> const& lhs_args = __jakt_match_value.args;
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((rhs)->index() == 20 /* GenericEnumInstance */)){
+types::EnumId const rhs_id = ((rhs)->get<types::Type::GenericEnumInstance>()).id;
+JaktInternal::DynamicArray<types::TypeId> const rhs_args = ((rhs)->get<types::Type::GenericEnumInstance>()).args;
+if ((((lhs_id).equals(rhs_id)) && (((lhs_args).size()) == ((rhs_args).size())))){
+size_t idx = static_cast<size_t>(0ULL);
+while ((idx < ((lhs_args).size()))){
+if ((!(((((lhs_args)[idx])).equals(((rhs_args)[idx])))))){
+return (false);
 }
-types::TypeId subtype_id = (_magic_value.value());
-{
-NonnullRefPtr<typename types::Type> const subtype = ((program)->get_type(subtype_id));
-({auto& _jakt_ref = specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((subtype)->specificity(program,(JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(4LL))))));});
+((idx++));
 }
-
+return (true);
 }
+else {
+return (false);
 }
 
-__jakt_var_135 = specificity; goto __jakt_label_131;
+}
+else {
+return (false);
+}
 
 }
-__jakt_label_131:; __jakt_var_135.release_value(); }));
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
-return JaktInternal::ExplicitValue(({ Optional<i64> __jakt_var_136; {
-i64 specificity = (JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(2LL)));
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& lhs_id = __jakt_match_value.value;
 {
-JaktInternal::ArrayIterator<types::TypeId> _magic = ((params).iterator());
-for (;;){
-JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+if (((rhs)->index() == 23 /* Struct */)){
+types::StructId const rhs_id = ((rhs)->get<types::Type::Struct>()).value;
+return (((lhs_id).equals(rhs_id)));
 }
-types::TypeId subtype_id = (_magic_value.value());
+return (false);
+}
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& lhs_id = __jakt_match_value.value;
 {
-NonnullRefPtr<typename types::Type> const subtype = ((program)->get_type(subtype_id));
-({auto& _jakt_ref = specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((subtype)->specificity(program,(JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(4LL))))));});
+if (((rhs)->index() == 24 /* Enum */)){
+types::EnumId const rhs_id = ((rhs)->get<types::Type::Enum>()).value;
+return (((lhs_id).equals(rhs_id)));
+}
+else {
+return (false);
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
+};/*case end*/
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::RawPtr>();
+types::TypeId const& lhs_id = __jakt_match_value.value;
+{
+if (((rhs)->index() == 25 /* RawPtr */)){
+types::TypeId const rhs_id = ((rhs)->get<types::Type::RawPtr>()).value;
+return (((lhs_id).equals(rhs_id)));
+}
+else {
+return (false);
 }
 
-__jakt_var_136 = specificity; goto __jakt_label_132;
-
 }
-__jakt_label_132:; __jakt_var_136.release_value(); }));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(base_specificity);
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Reference>();
+types::TypeId const& lhs_id = __jakt_match_value.value;
+{
+if (((rhs)->index() == 27 /* Reference */)){
+types::TypeId const rhs_id = ((rhs)->get<types::Type::Reference>()).value;
+return (((lhs_id).equals(rhs_id)));
 }
+else {
+return (false);
 }
 
-bool types::Type::is_concrete() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 18: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-case 30: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-case 16: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(true);
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::MutableReference>();
+types::TypeId const& lhs_id = __jakt_match_value.value;
+{
+if (((rhs)->index() == 28 /* MutableReference */)){
+types::TypeId const rhs_id = ((rhs)->get<types::Type::MutableReference>()).value;
+return (((lhs_id).equals(rhs_id)));
 }
+else {
+return (false);
 }
 
-bool types::Type::is_builtin() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 10: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 13: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 14: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Trait>();
+types::TraitId const& lhs_id = __jakt_match_value.value;
+{
+if (((rhs)->index() == 26 /* Trait */)){
+types::TraitId const rhs_id = ((rhs)->get<types::Type::Trait>()).value;
+return (((lhs_id).equals(rhs_id)));
 }
+else {
+return (false);
 }
 
-ErrorOr<types::TypeId> types::Type::flip_signedness() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<types::TypeId>>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 6: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } ));
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } ));
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } ));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } ));
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } ));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } ));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } ));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } ));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Unknown() } ));
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
+bool const& can_throw = __jakt_match_value.can_throw;
+types::TypeId const& return_type_id = __jakt_match_value.return_type_id;
+{
+if (((rhs)->index() == 29 /* Function */)){
+JaktInternal::DynamicArray<types::TypeId> const rhs_params = ((rhs)->get<types::Type::Function>()).params;
+bool const rhs_can_throw = ((rhs)->get<types::Type::Function>()).can_throw;
+types::TypeId const rhs_return_type_id = ((rhs)->get<types::Type::Function>()).return_type_id;
+if (((((params).size()) == ((rhs_params).size())) && (((return_type_id).equals(rhs_return_type_id)) && (can_throw == rhs_can_throw)))){
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((params).size()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+if ((!(((((params)[i])).equals(((rhs_params)[i])))))){
+return (false);
 }
 }
 
-u64 types::Type::max() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<u64, u64>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 14: {
-return JaktInternal::ExplicitValue(static_cast<u64>(127ULL));
-};/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue(static_cast<u64>(2147483647ULL));
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(static_cast<u64>(127ULL));
-};/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(static_cast<u64>(32767ULL));
-};/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(static_cast<u64>(2147483647ULL));
-};/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(static_cast<u64>(9223372036854775807ULL));
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(static_cast<u64>(255ULL));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(static_cast<u64>(65535ULL));
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(static_cast<u64>(4294967295ULL));
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(static_cast<u64>(18446744073709551615ULL));
-};/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(static_cast<u64>(18446744073709551615ULL));
+}
+}
+
+return (true);
+}
+else {
+return (false);
+}
+
+}
+else {
+return (false);
+}
+
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(static_cast<u64>(0ULL));
+{
+}
+return JaktInternal::ExplicitValue<void>();
 };/*case end*/
 }/*switch end*/
 }()
-)));
+));
+return (false);
 }
 }
 
@@ -3353,43 +3130,72 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-i64 types::Type::min() const {
+bool types::Type::is_concrete() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 14: {
-return JaktInternal::ExplicitValue((-(static_cast<i64>(128LL))));
+case 18: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 15: {
-return JaktInternal::ExplicitValue((-(static_cast<i64>(2147483648LL))));
+case 30: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue((-(static_cast<i64>(128LL))));
+case 16: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue((-(static_cast<i64>(32768LL))));
+default: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue((-(static_cast<i64>(2147483648LL))));
+}/*switch end*/
+}()
+)));
+}
+}
+
+i64 types::Type::get_bits() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue(static_cast<i64>(8LL));
 };/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue((JaktInternal::checked_sub<i64>((-(static_cast<i64>(9223372036854775807LL))),static_cast<i64>(1LL))));
+case 6: {
+return JaktInternal::ExplicitValue(static_cast<i64>(8LL));
 };/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+case 14: {
+return JaktInternal::ExplicitValue(static_cast<i64>(8LL));
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+return JaktInternal::ExplicitValue(static_cast<i64>(16LL));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue(static_cast<i64>(16LL));
 };/*case end*/
 case 4: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+return JaktInternal::ExplicitValue(static_cast<i64>(32LL));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(static_cast<i64>(32LL));
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue(static_cast<i64>(32LL));
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+return JaktInternal::ExplicitValue(static_cast<i64>(64LL));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(static_cast<i64>(64LL));
 };/*case end*/
 case 12: {
-return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+return JaktInternal::ExplicitValue(static_cast<i64>(64LL));
+};/*case end*/
+case 10: {
+return JaktInternal::ExplicitValue(static_cast<i64>(32LL));
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(static_cast<i64>(64LL));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
@@ -3400,352 +3206,350 @@ return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
 }
 }
 
-bool types::Type::is_signed() const {
+i64 types::Type::specificity(NonnullRefPtr<types::CheckedProgram> const program,i64 const base_specificity) const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 6: {
-return JaktInternal::ExplicitValue(true);
+case 18: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
 };/*case end*/
-case 7: {
-return JaktInternal::ExplicitValue(true);
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(({ Optional<i64> __jakt_var_133; {
+i64 specificity = (JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(2LL)));
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::TypeId subtype_id = (_magic_value.value());
+{
+NonnullRefPtr<typename types::Type> const subtype = ((program)->get_type(subtype_id));
+({auto& _jakt_ref = specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((subtype)->specificity(program,(JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(4LL))))));});
+}
+
+}
+}
+
+__jakt_var_133 = specificity; goto __jakt_label_129;
+
+}
+__jakt_label_129:; __jakt_var_133.release_value(); }));
 };/*case end*/
-case 8: {
-return JaktInternal::ExplicitValue(true);
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(({ Optional<i64> __jakt_var_134; {
+i64 specificity = (JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(2LL)));
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::TypeId subtype_id = (_magic_value.value());
+{
+NonnullRefPtr<typename types::Type> const subtype = ((program)->get_type(subtype_id));
+({auto& _jakt_ref = specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((subtype)->specificity(program,(JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(4LL))))));});
+}
+
+}
+}
+
+__jakt_var_134 = specificity; goto __jakt_label_130;
+
+}
+__jakt_label_130:; __jakt_var_134.release_value(); }));
 };/*case end*/
-case 9: {
-return JaktInternal::ExplicitValue(true);
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericResolvedType>();JaktInternal::DynamicArray<types::TypeId> const& args = __jakt_match_value.args;
+return JaktInternal::ExplicitValue(({ Optional<i64> __jakt_var_135; {
+i64 specificity = (JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(2LL)));
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((args).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::TypeId subtype_id = (_magic_value.value());
+{
+NonnullRefPtr<typename types::Type> const subtype = ((program)->get_type(subtype_id));
+({auto& _jakt_ref = specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((subtype)->specificity(program,(JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(4LL))))));});
+}
+
+}
+}
+
+__jakt_var_135 = specificity; goto __jakt_label_131;
+
+}
+__jakt_label_131:; __jakt_var_135.release_value(); }));
 };/*case end*/
-case 14: {
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::Function>();JaktInternal::DynamicArray<types::TypeId> const& params = __jakt_match_value.params;
+return JaktInternal::ExplicitValue(({ Optional<i64> __jakt_var_136; {
+i64 specificity = (JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(2LL)));
+{
+JaktInternal::ArrayIterator<types::TypeId> _magic = ((params).iterator());
+for (;;){
+JaktInternal::Optional<types::TypeId> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+types::TypeId subtype_id = (_magic_value.value());
+{
+NonnullRefPtr<typename types::Type> const subtype = ((program)->get_type(subtype_id));
+({auto& _jakt_ref = specificity;_jakt_ref = JaktInternal::checked_add<i64>(_jakt_ref, ((subtype)->specificity(program,(JaktInternal::checked_div<i64>(base_specificity,static_cast<i64>(4LL))))));});
+}
+
+}
+}
+
+__jakt_var_136 = specificity; goto __jakt_label_132;
+
+}
+__jakt_label_132:; __jakt_var_136.release_value(); }));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(base_specificity);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+}
+}
+
+bool types::Type::is_builtin() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
 return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 15: {
+case 1: {
 return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 2: {
-return JaktInternal::ExplicitValue(false);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(false);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 4: {
-return JaktInternal::ExplicitValue(false);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue(false);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(false);
+case 6: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 10: {
+case 7: {
 return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 11: {
+case 8: {
 return JaktInternal::ExplicitValue(true);
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 9: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<DeprecatedString> types::CheckedMatchBody::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Expression */: {
-TRY(builder.append("CheckedMatchBody::Expression"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedMatchBody::Expression>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* Block */: {
-TRY(builder.append("CheckedMatchBody::Block"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedMatchBody::Block>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> types::CheckedStatement::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Expression */: {
-TRY(builder.append("CheckedStatement::Expression"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Expression>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 1 /* Defer */: {
-TRY(builder.append("CheckedStatement::Defer"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Defer>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("statement: {}", that.statement));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 2 /* DestructuringAssignment */: {
-TRY(builder.append("CheckedStatement::DestructuringAssignment"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::DestructuringAssignment>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("vars: {}", that.vars));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("var_decl: {}", that.var_decl));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 3 /* VarDecl */: {
-TRY(builder.append("CheckedStatement::VarDecl"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::VarDecl>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("var_id: {}", that.var_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("init: {}", that.init));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 4 /* If */: {
-TRY(builder.append("CheckedStatement::If"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::If>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("condition: {}", that.condition));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("then_block: {}", that.then_block));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("else_statement: {}", that.else_statement));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 5 /* Block */: {
-TRY(builder.append("CheckedStatement::Block"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Block>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 6 /* Loop */: {
-TRY(builder.append("CheckedStatement::Loop"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Loop>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 7 /* While */: {
-TRY(builder.append("CheckedStatement::While"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::While>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("condition: {}", that.condition));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 8 /* Return */: {
-TRY(builder.append("CheckedStatement::Return"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Return>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: {}", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 9 /* Break */: {
-TRY(builder.append("CheckedStatement::Break"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Break>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 10 /* Continue */: {
-TRY(builder.append("CheckedStatement::Continue"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Continue>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 11 /* Throw */: {
-TRY(builder.append("CheckedStatement::Throw"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Throw>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 12 /* Yield */: {
-TRY(builder.append("CheckedStatement::Yield"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Yield>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 13 /* InlineCpp */: {
-TRY(builder.append("CheckedStatement::InlineCpp"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::InlineCpp>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("lines: {}", that.lines));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 14 /* Garbage */: {
-TRY(builder.append("CheckedStatement::Garbage"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Garbage>();
-TRY(builder.appendff("({})", that.value));
-break;}
+case 10: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 11: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 13: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 14: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
-return builder.to_string();
 }
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> types::CheckedStatement::none() {
+
+i64 types::Type::min() const {
 {
-return (JaktInternal::OptionalNone());
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<i64, i64>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 14: {
+return JaktInternal::ExplicitValue((-(static_cast<i64>(128LL))));
+};/*case end*/
+case 15: {
+return JaktInternal::ExplicitValue((-(static_cast<i64>(2147483648LL))));
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue((-(static_cast<i64>(128LL))));
+};/*case end*/
+case 7: {
+return JaktInternal::ExplicitValue((-(static_cast<i64>(32768LL))));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue((-(static_cast<i64>(2147483648LL))));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue((JaktInternal::checked_sub<i64>((-(static_cast<i64>(9223372036854775807LL))),static_cast<i64>(1LL))));
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+};/*case end*/
+case 12: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(static_cast<i64>(0LL));
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
 }
 
-JaktInternal::Optional<utility::Span> types::CheckedStatement::span() const {
+ErrorOr<types::TypeId> types::Type::flip_signedness() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<utility::Span>, JaktInternal::Optional<utility::Span>>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, ErrorOr<types::TypeId>>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<utility::Span>>(span));
+case 6: {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U8() } ));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 7: {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U16() } ));
+};/*case end*/
+case 8: {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U32() } ));
+};/*case end*/
+case 9: {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::U64() } ));
 };/*case end*/
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I8() } ));
 };/*case end*/
 case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I16() } ));
 };/*case end*/
 case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I32() } ));
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::I64() } ));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(types::builtin( types::BuiltinType { typename types::BuiltinType::Unknown() } ));
+};/*case end*/
+}/*switch end*/
+}()
+)));
+}
+}
+
+bool types::Type::is_boxed(NonnullRefPtr<types::CheckedProgram> const program) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Struct>();
+types::StructId const& struct_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((((program)->get_struct(struct_id))).record_type)).index() == 1 /* Class */));
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericInstance>();types::StructId const& struct_id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue(((((((program)->get_struct(struct_id))).record_type)).index() == 1 /* Class */));
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::Type::Enum>();
+types::EnumId const& enum_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((program)->get_enum(enum_id))).is_boxed));
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::Type::GenericEnumInstance>();types::EnumId const& enum_id = __jakt_match_value.id;
+return JaktInternal::ExplicitValue(((((program)->get_enum(enum_id))).is_boxed));
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
+}/*switch end*/
+}()
+)));
+}
+}
+
+bool types::Type::is_signed() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
 case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<utility::Span> const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedStatement::Break>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedStatement::Continue>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
+case 14: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 15: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
 case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::InlineCpp>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 10: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedStatement::Garbage>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
+case 11: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
 }()
 )));
 }
@@ -4597,123 +4401,90 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-ErrorOr<DeprecatedString> types::StructOrEnumId::debug_description() const {
+ErrorOr<DeprecatedString> types::BlockControlFlow::debug_description() const {
 auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Struct */: {
-TRY(builder.append("StructOrEnumId::Struct"sv));
-[[maybe_unused]] auto const& that = this->template get<StructOrEnumId::Struct>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* Enum */: {
-TRY(builder.append("StructOrEnumId::Enum"sv));
-[[maybe_unused]] auto const& that = this->template get<StructOrEnumId::Enum>();
-TRY(builder.appendff("({})", that.value));
+switch (this->index()) {case 0 /* AlwaysReturns */: {
+return DeprecatedString("BlockControlFlow::AlwaysReturns"sv);
 break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> types::CheckedEnumVariant::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Untyped */: {
-TRY(builder.append("CheckedEnumVariant::Untyped"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedEnumVariant::Untyped>();
+case 1 /* AlwaysTransfersControl */: {
+TRY(builder.append("BlockControlFlow::AlwaysTransfersControl"sv));
+[[maybe_unused]] auto const& that = this->template get<BlockControlFlow::AlwaysTransfersControl>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("enum_id: {}", that.enum_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("might_break: {}", that.might_break));
 }
 TRY(builder.append(")"sv));
 break;}
-case 1 /* Typed */: {
-TRY(builder.append("CheckedEnumVariant::Typed"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedEnumVariant::Typed>();
+case 2 /* NeverReturns */: {
+return DeprecatedString("BlockControlFlow::NeverReturns"sv);
+break;}
+case 3 /* MayReturn */: {
+return DeprecatedString("BlockControlFlow::MayReturn"sv);
+break;}
+case 4 /* PartialAlwaysReturns */: {
+TRY(builder.append("BlockControlFlow::PartialAlwaysReturns"sv));
+[[maybe_unused]] auto const& that = this->template get<BlockControlFlow::PartialAlwaysReturns>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("enum_id: {}", that.enum_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("might_break: {}", that.might_break));
 }
 TRY(builder.append(")"sv));
 break;}
-case 2 /* WithValue */: {
-TRY(builder.append("CheckedEnumVariant::WithValue"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedEnumVariant::WithValue>();
+case 5 /* PartialAlwaysTransfersControl */: {
+TRY(builder.append("BlockControlFlow::PartialAlwaysTransfersControl"sv));
+[[maybe_unused]] auto const& that = this->template get<BlockControlFlow::PartialAlwaysTransfersControl>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("enum_id: {}", that.enum_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("might_break: {}", that.might_break));
 }
 TRY(builder.append(")"sv));
 break;}
-case 3 /* StructLike */: {
-TRY(builder.append("CheckedEnumVariant::StructLike"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedEnumVariant::StructLike>();
+case 6 /* PartialNeverReturns */: {
+TRY(builder.append("BlockControlFlow::PartialNeverReturns"sv));
+[[maybe_unused]] auto const& that = this->template get<BlockControlFlow::PartialNeverReturns>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("enum_id: {}", that.enum_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("fields: {}", that.fields));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("might_break: {}", that.might_break));
 }
 TRY(builder.append(")"sv));
 break;}
 }
 return builder.to_string();
 }
-types::EnumId types::CheckedEnumVariant::enum_id() const {
+types::BlockControlFlow types::BlockControlFlow::updated(types::BlockControlFlow const second) const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, types::EnumId>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
+};/*case end*/
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
-return JaktInternal::ExplicitValue(enum_id);
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
-return JaktInternal::ExplicitValue(enum_id);
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
-return JaktInternal::ExplicitValue(enum_id);
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
 };/*case end*/
 case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
-return JaktInternal::ExplicitValue(enum_id);
+return JaktInternal::ExplicitValue(second);
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(((*this).unify_with(second)));
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(((*this).unify_with(second)));
+};/*case end*/
+case 6: {
+return JaktInternal::ExplicitValue(((*this).unify_with(second)));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
@@ -4721,83 +4492,275 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-DeprecatedString types::CheckedEnumVariant::name() const {
+bool types::BlockControlFlow::is_reachable() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, DeprecatedString>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+}
+}
+
+bool types::BlockControlFlow::always_returns() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(name);
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
+};/*case end*/
+}/*switch end*/
+}()
+)));
+}
+}
+
+bool types::BlockControlFlow::always_transfers_control() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(name);
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
+}/*switch end*/
+}()
+)));
+}
+}
+
+types::BlockControlFlow types::BlockControlFlow::branch_unify_with(types::BlockControlFlow const second) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
 case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(name);
+return JaktInternal::ExplicitValue(second);
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
+switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
 case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(name);
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(might_break) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(might_break) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
+switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(might_break) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(might_break) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& this_might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
+switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(this_might_break) } );
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(this_might_break) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(this_might_break) } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns((might_break || this_might_break)) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((might_break || this_might_break)) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& this_might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
+switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(this_might_break) } );
+};/*case end*/
+case 0: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(this_might_break) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(this_might_break) } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((might_break || this_might_break)) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((might_break || this_might_break)) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-}
-}
-
-bool types::CheckedEnumVariant::equals(types::CheckedEnumVariant const other) const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& this_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = other;
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& this_might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
 switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(this_might_break) } );
+};/*case end*/
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& other_name = __jakt_match_value.name;
-return JaktInternal::ExplicitValue((this_name == other_name));
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(this_might_break) } );
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(this_might_break) } );
 };/*case end*/
-}/*switch end*/
-}()
-)));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
 };/*case end*/
-}/*switch end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-}
-}
-
-utility::Span types::CheckedEnumVariant::span() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
-auto&& __jakt_match_variant = *this;
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& this_might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
 switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(this_might_break) } );
+};/*case end*/
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(this_might_break) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(this_might_break) } );
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((might_break || this_might_break)) } );
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns((might_break || this_might_break)) } );
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((might_break || this_might_break)) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
@@ -4805,160 +4768,62 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-ErrorOr<DeprecatedString> types::CheckedMatchCase::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* EnumVariant */: {
-TRY(builder.append("CheckedMatchCase::EnumVariant"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedMatchCase::EnumVariant>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("defaults: {}", that.defaults));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("name: \"{}\"", that.name));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("args: {}", that.args));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("subject_type_id: {}", that.subject_type_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: {}", that.index));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("scope_id: {}", that.scope_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("body: {}", that.body));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("marker_span: {}", that.marker_span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 1 /* Expression */: {
-TRY(builder.append("CheckedMatchCase::Expression"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedMatchCase::Expression>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("defaults: {}", that.defaults));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expression: {}", that.expression));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("body: {}", that.body));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("marker_span: {}", that.marker_span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 2 /* CatchAll */: {
-TRY(builder.append("CheckedMatchCase::CatchAll"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedMatchCase::CatchAll>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("defaults: {}", that.defaults));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("has_arguments: {}", that.has_arguments));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("body: {}", that.body));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("marker_span: {}", that.marker_span));
-}
-TRY(builder.append(")"sv));
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> types::CheckedTypeCast::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Fallible */: {
-TRY(builder.append("CheckedTypeCast::Fallible"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedTypeCast::Fallible>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* Infallible */: {
-TRY(builder.append("CheckedTypeCast::Infallible"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedTypeCast::Infallible>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-types::TypeId types::CheckedTypeCast::type_id() const {
+types::BlockControlFlow types::BlockControlFlow::definitive() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, types::TypeId>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
+};/*case end*/
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Fallible>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(type_id);
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Infallible>();
-types::TypeId const& type_id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(type_id);
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+}/*switch end*/
 }()
 )));
 }
 }
 
-ErrorOr<DeprecatedString> types::NumberConstant::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Signed */: {
-TRY(builder.append("NumberConstant::Signed"sv));
-[[maybe_unused]] auto const& that = this->template get<NumberConstant::Signed>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* Unsigned */: {
-TRY(builder.append("NumberConstant::Unsigned"sv));
-[[maybe_unused]] auto const& that = this->template get<NumberConstant::Unsigned>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 2 /* Floating */: {
-TRY(builder.append("NumberConstant::Floating"sv));
-[[maybe_unused]] auto const& that = this->template get<NumberConstant::Floating>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-size_t types::NumberConstant::to_usize() const {
+types::BlockControlFlow types::BlockControlFlow::partial() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, size_t>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(false) } );
+};/*case end*/
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Signed>();
-i64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((value))));
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(false) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Unsigned>();
-u64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((value))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(might_break) } );
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Floating>();
-f64 const& value = __jakt_match_value.value;
-{
-utility::panic(Jakt::DeprecatedString("to_usize on a floating point constant"sv));
-}
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(might_break) } );
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
@@ -4966,310 +4831,229 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-bool types::NumberConstant::can_fit_number(types::TypeId const type_id,NonnullRefPtr<types::CheckedProgram> const program) const {
+bool types::BlockControlFlow::may_break() const {
 {
-NonnullRefPtr<typename types::Type> const type_ = ((program)->get_type(type_id));
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Signed>();
-i64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *type_;
-switch(__jakt_match_variant.index()) {
-case 9: {
-return JaktInternal::ExplicitValue(true);
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(might_break);
 };/*case end*/
 case 5: {
-return JaktInternal::ExplicitValue((value >= static_cast<i64>(0LL)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(might_break);
 };/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue((value >= static_cast<i64>(0LL)));
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(might_break);
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(might_break);
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(((((program)->is_integer(type_id)) && (value >= ((type_)->min()))) && (value <= (infallible_integer_cast<i64>((((type_)->max())))))));
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
 }/*switch end*/
 }()
 )));
+}
+}
+
+types::BlockControlFlow types::BlockControlFlow::unify_with(types::BlockControlFlow const second) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 2: {
+return JaktInternal::ExplicitValue(second);
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Unsigned>();
-u64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *type_;
+case 0: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
 switch(__jakt_match_variant.index()) {
-case 5: {
-return JaktInternal::ExplicitValue(true);
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
-case 12: {
-return JaktInternal::ExplicitValue(true);
+case 0: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue((((program)->is_integer(type_id)) && (value <= ((type_)->max()))));
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
 };/*case end*/
-}/*switch end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
 };/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Floating>();
-f64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *type_;
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& lhs = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
 switch(__jakt_match_variant.index()) {
-case 10: {
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_143; {
-utility::todo(Jakt::DeprecatedString("Implement casting f32 to f64"sv));
-__jakt_var_143 = false; goto __jakt_label_139;
-
-}
-__jakt_label_139:; __jakt_var_143.release_value(); }));
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
 };/*case end*/
-case 11: {
-return JaktInternal::ExplicitValue(true);
+case 0: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((lhs || might_break)) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(false);
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
 };/*case end*/
 }/*switch end*/
 }()
 )));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<DeprecatedString> types::CheckedUnaryOperator::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* PreIncrement */: {
-return DeprecatedString("CheckedUnaryOperator::PreIncrement"sv);
-break;}
-case 1 /* PostIncrement */: {
-return DeprecatedString("CheckedUnaryOperator::PostIncrement"sv);
-break;}
-case 2 /* PreDecrement */: {
-return DeprecatedString("CheckedUnaryOperator::PreDecrement"sv);
-break;}
-case 3 /* PostDecrement */: {
-return DeprecatedString("CheckedUnaryOperator::PostDecrement"sv);
-break;}
-case 4 /* Negate */: {
-return DeprecatedString("CheckedUnaryOperator::Negate"sv);
-break;}
-case 5 /* Dereference */: {
-return DeprecatedString("CheckedUnaryOperator::Dereference"sv);
-break;}
-case 6 /* RawAddress */: {
-return DeprecatedString("CheckedUnaryOperator::RawAddress"sv);
-break;}
-case 7 /* Reference */: {
-return DeprecatedString("CheckedUnaryOperator::Reference"sv);
-break;}
-case 8 /* MutableReference */: {
-return DeprecatedString("CheckedUnaryOperator::MutableReference"sv);
-break;}
-case 9 /* LogicalNot */: {
-return DeprecatedString("CheckedUnaryOperator::LogicalNot"sv);
-break;}
-case 10 /* BitwiseNot */: {
-return DeprecatedString("CheckedUnaryOperator::BitwiseNot"sv);
-break;}
-case 11 /* TypeCast */: {
-TRY(builder.append("CheckedUnaryOperator::TypeCast"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedUnaryOperator::TypeCast>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 12 /* Is */: {
-TRY(builder.append("CheckedUnaryOperator::Is"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedUnaryOperator::Is>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 13 /* IsEnumVariant */: {
-TRY(builder.append("CheckedUnaryOperator::IsEnumVariant"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedUnaryOperator::IsEnumVariant>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("enum_variant: {}", that.enum_variant));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("bindings: {}", that.bindings));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
-}
-TRY(builder.append(")"sv));
-break;}
-case 14 /* Sizeof */: {
-TRY(builder.append("CheckedUnaryOperator::Sizeof"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedUnaryOperator::Sizeof>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> types::BlockControlFlow::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* AlwaysReturns */: {
-return DeprecatedString("BlockControlFlow::AlwaysReturns"sv);
-break;}
-case 1 /* AlwaysTransfersControl */: {
-TRY(builder.append("BlockControlFlow::AlwaysTransfersControl"sv));
-[[maybe_unused]] auto const& that = this->template get<BlockControlFlow::AlwaysTransfersControl>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("might_break: {}", that.might_break));
-}
-TRY(builder.append(")"sv));
-break;}
-case 2 /* NeverReturns */: {
-return DeprecatedString("BlockControlFlow::NeverReturns"sv);
-break;}
-case 3 /* MayReturn */: {
-return DeprecatedString("BlockControlFlow::MayReturn"sv);
-break;}
-case 4 /* PartialAlwaysReturns */: {
-TRY(builder.append("BlockControlFlow::PartialAlwaysReturns"sv));
-[[maybe_unused]] auto const& that = this->template get<BlockControlFlow::PartialAlwaysReturns>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("might_break: {}", that.might_break));
-}
-TRY(builder.append(")"sv));
-break;}
-case 5 /* PartialAlwaysTransfersControl */: {
-TRY(builder.append("BlockControlFlow::PartialAlwaysTransfersControl"sv));
-[[maybe_unused]] auto const& that = this->template get<BlockControlFlow::PartialAlwaysTransfersControl>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("might_break: {}", that.might_break));
-}
-TRY(builder.append(")"sv));
-break;}
-case 6 /* PartialNeverReturns */: {
-TRY(builder.append("BlockControlFlow::PartialNeverReturns"sv));
-[[maybe_unused]] auto const& that = this->template get<BlockControlFlow::PartialNeverReturns>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("might_break: {}", that.might_break));
-}
-TRY(builder.append(")"sv));
-break;}
-}
-return builder.to_string();
-}
-bool types::BlockControlFlow::always_transfers_control() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
+case 3: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
 switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
 case 1: {
-return JaktInternal::ExplicitValue(true);
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(might_break) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(might_break) } );
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(false);
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
 };/*case end*/
 }/*switch end*/
 }()
 )));
-}
-}
-
-types::BlockControlFlow types::BlockControlFlow::partial() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = *this;
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& lhs = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
 switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(false) } );
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((lhs || might_break)) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
 };/*case end*/
 case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(false) } );
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((lhs || might_break)) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
 };/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& lhs = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
+switch(__jakt_match_variant.index()) {
 case 5: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
 };/*case end*/
 case 4: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(might_break) } );
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
 };/*case end*/
 case 6: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(might_break) } );
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-bool types::BlockControlFlow::always_returns() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
 case 0: {
-return JaktInternal::ExplicitValue(true);
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
 };/*case end*/
-}/*switch end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((lhs || might_break)) } );
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(lhs) } );
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-}
-}
-
-types::BlockControlFlow types::BlockControlFlow::updated(types::BlockControlFlow const second) const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = *this;
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& lhs = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+auto&& __jakt_match_variant = second;
 switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns((lhs || might_break)) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
 };/*case end*/
 case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
 };/*case end*/
 case 1: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((lhs || might_break)) } );
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue(second);
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(((*this).unify_with(second)));
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(lhs) } );
 };/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(((*this).unify_with(second)));
+case 2: {
+return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
 };/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(((*this).unify_with(second)));
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
@@ -5277,26 +5061,22 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-bool types::BlockControlFlow::may_break() const {
+bool types::BlockControlFlow::may_return() const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
+case 3: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
 case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(might_break);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(might_break);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(might_break);
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(might_break);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -5307,308 +5087,423 @@ return JaktInternal::ExplicitValue(false);
 }
 }
 
-bool types::BlockControlFlow::is_reachable() const {
+bool types::BlockControlFlow::never_returns() const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
 case 2: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(false);
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(true);
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
 }/*switch end*/
 }()
 )));
 }
 }
-
-bool types::BlockControlFlow::never_returns() const {
+
+ErrorOr<DeprecatedString> types::CheckedMatchBody::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Expression */: {
+TRY(builder.append("CheckedMatchBody::Expression"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedMatchBody::Expression>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 1 /* Block */: {
+TRY(builder.append("CheckedMatchBody::Block"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedMatchBody::Block>();
+TRY(builder.appendff("({})", that.value));
+break;}
+}
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> types::CheckedStatement::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Expression */: {
+TRY(builder.append("CheckedStatement::Expression"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Expression>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 1 /* Defer */: {
+TRY(builder.append("CheckedStatement::Defer"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Defer>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("statement: {}", that.statement));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 2 /* DestructuringAssignment */: {
+TRY(builder.append("CheckedStatement::DestructuringAssignment"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::DestructuringAssignment>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("vars: {}", that.vars));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("var_decl: {}", that.var_decl));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 3 /* VarDecl */: {
+TRY(builder.append("CheckedStatement::VarDecl"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::VarDecl>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("var_id: {}", that.var_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("init: {}", that.init));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 4 /* If */: {
+TRY(builder.append("CheckedStatement::If"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::If>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("condition: {}", that.condition));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("then_block: {}", that.then_block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("else_statement: {}", that.else_statement));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 5 /* Block */: {
+TRY(builder.append("CheckedStatement::Block"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Block>();
+TRY(builder.append("("sv));
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("block: {}", that.block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
+TRY(builder.append(")"sv));
+break;}
+case 6 /* Loop */: {
+TRY(builder.append("CheckedStatement::Loop"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Loop>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("block: {}", that.block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-
-types::BlockControlFlow types::BlockControlFlow::definitive() const {
+TRY(builder.append(")"sv));
+break;}
+case 7 /* While */: {
+TRY(builder.append("CheckedStatement::While"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::While>();
+TRY(builder.append("("sv));
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-}/*switch end*/
-}()
-)));
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("condition: {}", that.condition));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("block: {}", that.block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
+TRY(builder.append(")"sv));
+break;}
+case 8 /* Return */: {
+TRY(builder.append("CheckedStatement::Return"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Return>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("val: {}", that.val));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-
-bool types::BlockControlFlow::may_return() const {
+TRY(builder.append(")"sv));
+break;}
+case 9 /* Break */: {
+TRY(builder.append("CheckedStatement::Break"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Break>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 10 /* Continue */: {
+TRY(builder.append("CheckedStatement::Continue"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Continue>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 11 /* Throw */: {
+TRY(builder.append("CheckedStatement::Throw"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Throw>();
+TRY(builder.append("("sv));
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 3: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 6: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
+TRY(builder.append(")"sv));
+break;}
+case 12 /* Yield */: {
+TRY(builder.append("CheckedStatement::Yield"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Yield>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-
-types::BlockControlFlow types::BlockControlFlow::branch_unify_with(types::BlockControlFlow const second) const {
+TRY(builder.append(")"sv));
+break;}
+case 13 /* InlineCpp */: {
+TRY(builder.append("CheckedStatement::InlineCpp"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::InlineCpp>();
+TRY(builder.append("("sv));
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue(second);
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(might_break) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(might_break) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(might_break) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(might_break) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& this_might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("lines: {}", that.lines));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 14 /* Garbage */: {
+TRY(builder.append("CheckedStatement::Garbage"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedStatement::Garbage>();
+TRY(builder.appendff("({})", that.value));
+break;}
+}
+return builder.to_string();
+}
+JaktInternal::Optional<utility::Span> types::CheckedStatement::span() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<utility::Span>, JaktInternal::Optional<utility::Span>>{
+auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(this_might_break) } );
-};/*case end*/
 case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(this_might_break) } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(this_might_break) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Expression>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(static_cast<JaktInternal::Optional<utility::Span>>(span));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns((might_break || this_might_break)) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((might_break || this_might_break)) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Defer>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& this_might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
-switch(__jakt_match_variant.index()) {
 case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(this_might_break) } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(this_might_break) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::DestructuringAssignment>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(this_might_break) } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((might_break || this_might_break)) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::VarDecl>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((might_break || this_might_break)) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::If>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Block>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Loop>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& this_might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(this_might_break) } );
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::While>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(this_might_break) } );
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Return>();JaktInternal::Optional<utility::Span> const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(this_might_break) } );
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedStatement::Break>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedStatement::Continue>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Throw>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::Yield>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedStatement::InlineCpp>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedStatement::Garbage>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& this_might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
+}
+}
+
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> types::CheckedStatement::none() {
+{
+return (JaktInternal::OptionalNone());
+}
+}
+
+ErrorOr<DeprecatedString> types::CheckedEnumVariant::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Untyped */: {
+TRY(builder.append("CheckedEnumVariant::Untyped"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedEnumVariant::Untyped>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("enum_id: {}", that.enum_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 1 /* Typed */: {
+TRY(builder.append("CheckedEnumVariant::Typed"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedEnumVariant::Typed>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("enum_id: {}", that.enum_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 2 /* WithValue */: {
+TRY(builder.append("CheckedEnumVariant::WithValue"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedEnumVariant::WithValue>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("enum_id: {}", that.enum_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 3 /* StructLike */: {
+TRY(builder.append("CheckedEnumVariant::StructLike"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedEnumVariant::StructLike>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("enum_id: {}", that.enum_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("fields: {}", that.fields));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+}
+TRY(builder.append(")"sv));
+break;}
+}
+return builder.to_string();
+}
+types::EnumId types::CheckedEnumVariant::enum_id() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::EnumId, types::EnumId>{
+auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(this_might_break) } );
-};/*case end*/
 case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(this_might_break) } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(this_might_break) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
+return JaktInternal::ExplicitValue(enum_id);
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((might_break || this_might_break)) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns((might_break || this_might_break)) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((might_break || this_might_break)) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
+return JaktInternal::ExplicitValue(enum_id);
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((might_break || this_might_break)) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
+return JaktInternal::ExplicitValue(enum_id);
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();types::EnumId const& enum_id = __jakt_match_value.enum_id;
+return JaktInternal::ExplicitValue(enum_id);
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
@@ -5616,197 +5511,291 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-types::BlockControlFlow types::BlockControlFlow::unify_with(types::BlockControlFlow const second) const {
+DeprecatedString types::CheckedEnumVariant::name() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, DeprecatedString>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue(second);
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
-switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
-};/*case end*/
 case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(name);
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(name);
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(name);
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();DeprecatedString const& name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(name);
 };/*case end*/
 default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& lhs = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
+}
+}
+
+bool types::CheckedEnumVariant::equals(types::CheckedEnumVariant const other) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
-};/*case end*/
 case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& this_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = other;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();DeprecatedString const& other_name = __jakt_match_value.name;
+return JaktInternal::ExplicitValue((this_name == other_name));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((lhs || might_break)) } );
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
+}/*switch end*/
+}()
+)));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
 }/*switch end*/
 }()
 )));
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
+}
+}
+
+utility::Span types::CheckedEnumVariant::span() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
+auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Untyped>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(might_break) } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::Typed>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns(might_break) } );
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::WithValue>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(might_break) } );
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedEnumVariant::StructLike>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(might_break) } );
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
+ErrorOr<DeprecatedString> types::CheckedMatchCase::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* EnumVariant */: {
+TRY(builder.append("CheckedMatchCase::EnumVariant"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedMatchCase::EnumVariant>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("defaults: {}", that.defaults));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("name: \"{}\"", that.name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("args: {}", that.args));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("subject_type_id: {}", that.subject_type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: {}", that.index));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("scope_id: {}", that.scope_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("body: {}", that.body));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("marker_span: {}", that.marker_span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 1 /* Expression */: {
+TRY(builder.append("CheckedMatchCase::Expression"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedMatchCase::Expression>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("defaults: {}", that.defaults));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expression: {}", that.expression));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("body: {}", that.body));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("marker_span: {}", that.marker_span));
+}
+TRY(builder.append(")"sv));
+break;}
+case 2 /* CatchAll */: {
+TRY(builder.append("CheckedMatchCase::CatchAll"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedMatchCase::CatchAll>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("defaults: {}", that.defaults));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("has_arguments: {}", that.has_arguments));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("body: {}", that.body));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("marker_span: {}", that.marker_span));
+}
+TRY(builder.append(")"sv));
+break;}
+}
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> types::CheckedTypeCast::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Fallible */: {
+TRY(builder.append("CheckedTypeCast::Fallible"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedTypeCast::Fallible>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 1 /* Infallible */: {
+TRY(builder.append("CheckedTypeCast::Infallible"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedTypeCast::Infallible>();
+TRY(builder.appendff("({})", that.value));
+break;}
+}
+return builder.to_string();
+}
+types::TypeId types::CheckedTypeCast::type_id() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, types::TypeId>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Fallible>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(type_id);
 };/*case end*/
-default: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedTypeCast::Infallible>();
+types::TypeId const& type_id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(type_id);
 };/*case end*/
-}/*switch end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
 }()
 )));
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& lhs = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
+}
+}
+
+ErrorOr<DeprecatedString> types::NumberConstant::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Signed */: {
+TRY(builder.append("NumberConstant::Signed"sv));
+[[maybe_unused]] auto const& that = this->template get<NumberConstant::Signed>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 1 /* Unsigned */: {
+TRY(builder.append("NumberConstant::Unsigned"sv));
+[[maybe_unused]] auto const& that = this->template get<NumberConstant::Unsigned>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 2 /* Floating */: {
+TRY(builder.append("NumberConstant::Floating"sv));
+[[maybe_unused]] auto const& that = this->template get<NumberConstant::Floating>();
+TRY(builder.appendff("({})", that.value));
+break;}
+}
+return builder.to_string();
+}
+bool types::NumberConstant::can_fit_number(types::TypeId const type_id,NonnullRefPtr<types::CheckedProgram> const program) const {
+{
+NonnullRefPtr<typename types::Type> const type_ = ((program)->get_type(type_id));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysReturns((lhs || might_break)) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
-};/*case end*/
 case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysReturns() } );
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Signed>();
+i64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *type_;
+switch(__jakt_match_variant.index()) {
+case 9: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
+case 5: {
+return JaktInternal::ExplicitValue((value >= static_cast<i64>(0LL)));
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((lhs || might_break)) } );
+case 12: {
+return JaktInternal::ExplicitValue((value >= static_cast<i64>(0LL)));
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
+default: {
+return JaktInternal::ExplicitValue(((((program)->is_integer(type_id)) && (value >= ((type_)->min()))) && (value <= (infallible_integer_cast<i64>((((type_)->max())))))));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& lhs = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Unsigned>();
+u64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *type_;
 switch(__jakt_match_variant.index()) {
 case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((lhs || might_break)) } );
+case 12: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl(lhs) } );
+default: {
+return JaktInternal::ExplicitValue((((program)->is_integer(type_id)) && (value <= ((type_)->max()))));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& lhs = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow, types::BlockControlFlow>{
-auto&& __jakt_match_variant = second;
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Floating>();
+f64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *type_;
 switch(__jakt_match_variant.index()) {
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialNeverReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns((lhs || might_break)) } );
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::PartialAlwaysReturns>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialAlwaysTransfersControl((lhs || might_break)) } );
-};/*case end*/
-case 0: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl(lhs) } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::BlockControlFlow::AlwaysTransfersControl>();bool const& might_break = __jakt_match_value.might_break;
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::AlwaysTransfersControl((lhs || might_break)) } );
+case 10: {
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_143; {
+utility::todo(Jakt::DeprecatedString("Implement casting f32 to f64"sv));
+__jakt_var_143 = false; goto __jakt_label_139;
+
+}
+__jakt_label_139:; __jakt_var_143.release_value(); }));
 };/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::PartialNeverReturns(lhs) } );
+case 11: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::NeverReturns() } );
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
+}/*switch end*/
 }()
 )));
 };/*case end*/
@@ -5816,603 +5805,501 @@ default: VERIFY_NOT_REACHED();}/*switch end*/
 }
 }
 
-ErrorOr<DeprecatedString> types::CheckedCapture::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* ByValue */: {
-return DeprecatedString("CheckedCapture::ByValue"sv);
-break;}
-case 1 /* ByReference */: {
-return DeprecatedString("CheckedCapture::ByReference"sv);
-break;}
-case 2 /* ByMutableReference */: {
-return DeprecatedString("CheckedCapture::ByMutableReference"sv);
-break;}
-case 3 /* ByComptimeDependency */: {
-return DeprecatedString("CheckedCapture::ByComptimeDependency"sv);
-break;}
-case 4 /* AllByReference */: {
-return DeprecatedString("CheckedCapture::AllByReference"sv);
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> types::SafetyMode::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Safe */: {
-return DeprecatedString("SafetyMode::Safe"sv);
-break;}
-case 1 /* Unsafe */: {
-return DeprecatedString("SafetyMode::Unsafe"sv);
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<DeprecatedString> types::MaybeResolvedScope::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Resolved */: {
-TRY(builder.append("MaybeResolvedScope::Resolved"sv));
-[[maybe_unused]] auto const& that = this->template get<MaybeResolvedScope::Resolved>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* Unresolved */: {
-TRY(builder.append("MaybeResolvedScope::Unresolved"sv));
-[[maybe_unused]] auto const& that = this->template get<MaybeResolvedScope::Unresolved>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("parent_scope: {}", that.parent_scope));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("relative_name: \"{}\"", that.relative_name));
-}
-TRY(builder.append(")"sv));
-break;}
-}
-return builder.to_string();
-}
-ErrorOr<NonnullRefPtr<typename types::MaybeResolvedScope>> types::MaybeResolvedScope::try_resolve(NonnullRefPtr<types::CheckedProgram> const program) const {
+size_t types::NumberConstant::to_usize() const {
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::MaybeResolvedScope>, ErrorOr<NonnullRefPtr<typename types::MaybeResolvedScope>>>{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<size_t, size_t>{
 auto&& __jakt_match_variant = *this;
 switch(__jakt_match_variant.index()) {
 case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::MaybeResolvedScope::Resolved>();
-types::ScopeId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Resolved>(id))));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Signed>();
+i64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((value))));
 };/*case end*/
 case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::MaybeResolvedScope::Unresolved>();NonnullRefPtr<typename types::MaybeResolvedScope> const& parent_scope = __jakt_match_value.parent_scope;
-DeprecatedString const& relative_name = __jakt_match_value.relative_name;
-return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::MaybeResolvedScope>> __jakt_var_144; {
-NonnullRefPtr<typename types::MaybeResolvedScope> parent = TRY((((parent_scope)->try_resolve(program))));
-if (((parent)->index() == 0 /* Resolved */)){
-types::ScopeId const parent_scope_id = ((parent)->get<types::MaybeResolvedScope::Resolved>()).value;
-types::ScopeId const scope = parent_scope_id;
-JaktInternal::Optional<types::ScopeId> scope_id = JaktInternal::OptionalNone();
-if ((!(((scope_id).has_value())))){
-JaktInternal::Optional<types::StructId> const struct_ = TRY((((program)->find_struct_in_scope(scope,relative_name))));
-if (((struct_).has_value())){
-(scope_id = ((((program)->get_struct((struct_.value())))).scope_id));
-}
-}
-if ((!(((scope_id).has_value())))){
-JaktInternal::Optional<types::EnumId> const enum_ = TRY((((program)->find_enum_in_scope(scope,relative_name))));
-if (((enum_).has_value())){
-(scope_id = ((((program)->get_enum((enum_.value())))).scope_id));
-}
-}
-if ((!(((scope_id).has_value())))){
-JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const ns = TRY((((program)->find_namespace_in_scope(scope,relative_name,false))));
-if (((ns).has_value())){
-(scope_id = (((ns.value())).template get<0>()));
-}
-}
-if ((!(((scope_id).has_value())))){
-JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const ids = TRY((((program)->find_functions_with_name_in_scope(scope,relative_name))));
-if (((ids).has_value())){
-(scope_id = ((((program)->get_function((((ids.value()))[static_cast<i64>(0LL)]))))->function_scope_id));
-}
-}
-if (((scope_id).has_value())){
-return (TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Resolved>((scope_id.value())))));
-}
-}
-__jakt_var_144 = TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Unresolved>(parent,relative_name))); goto __jakt_label_140;
-
-}
-__jakt_label_140:; __jakt_var_144.release_value(); }));
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Unsigned>();
+u64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue((infallible_integer_cast<size_t>((value))));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-ErrorOr<DeprecatedString> types::CheckedExpression::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Boolean */: {
-TRY(builder.append("CheckedExpression::Boolean"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Boolean>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: {}", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 1 /* NumericConstant */: {
-TRY(builder.append("CheckedExpression::NumericConstant"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::NumericConstant>();
-TRY(builder.append("("sv));
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::NumberConstant::Floating>();
+f64 const& value = __jakt_match_value.value;
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: {}", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
+utility::panic(Jakt::DeprecatedString("to_usize on a floating point constant"sv));
 }
-TRY(builder.append(")"sv));
-break;}
-case 2 /* QuotedString */: {
-TRY(builder.append("CheckedExpression::QuotedString"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::QuotedString>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: {}", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-TRY(builder.append(")"sv));
-break;}
-case 3 /* ByteConstant */: {
-TRY(builder.append("CheckedExpression::ByteConstant"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::ByteConstant>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: \"{}\"", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
 }
-TRY(builder.append(")"sv));
+
+ErrorOr<DeprecatedString> types::CheckedVisibility::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Public */: {
+return DeprecatedString("CheckedVisibility::Public"sv);
 break;}
-case 4 /* CharacterConstant */: {
-TRY(builder.append("CheckedExpression::CharacterConstant"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::CharacterConstant>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: \"{}\"", that.val));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
+case 1 /* Private */: {
+return DeprecatedString("CheckedVisibility::Private"sv);
 break;}
-case 5 /* CCharacterConstant */: {
-TRY(builder.append("CheckedExpression::CCharacterConstant"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::CCharacterConstant>();
+case 2 /* Restricted */: {
+TRY(builder.append("CheckedVisibility::Restricted"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedVisibility::Restricted>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("val: \"{}\"", that.val));
+TRY(builder.appendff("scopes: {}", that.scopes));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 6 /* UnaryOp */: {
-TRY(builder.append("CheckedExpression::UnaryOp"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::UnaryOp>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("op: {}", that.op));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
 }
-TRY(builder.append(")"sv));
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> types::CheckedNumericConstant::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* I8 */: {
+TRY(builder.append("CheckedNumericConstant::I8"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::I8>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 7 /* BinaryOp */: {
-TRY(builder.append("CheckedExpression::BinaryOp"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::BinaryOp>();
-TRY(builder.append("("sv));
+case 1 /* I16 */: {
+TRY(builder.append("CheckedNumericConstant::I16"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::I16>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 2 /* I32 */: {
+TRY(builder.append("CheckedNumericConstant::I32"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::I32>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 3 /* I64 */: {
+TRY(builder.append("CheckedNumericConstant::I64"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::I64>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 4 /* U8 */: {
+TRY(builder.append("CheckedNumericConstant::U8"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::U8>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 5 /* U16 */: {
+TRY(builder.append("CheckedNumericConstant::U16"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::U16>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 6 /* U32 */: {
+TRY(builder.append("CheckedNumericConstant::U32"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::U32>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 7 /* U64 */: {
+TRY(builder.append("CheckedNumericConstant::U64"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::U64>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 8 /* USize */: {
+TRY(builder.append("CheckedNumericConstant::USize"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::USize>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 9 /* F32 */: {
+TRY(builder.append("CheckedNumericConstant::F32"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::F32>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 10 /* F64 */: {
+TRY(builder.append("CheckedNumericConstant::F64"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::F64>();
+TRY(builder.appendff("({})", that.value));
+break;}
+}
+return builder.to_string();
+}
+JaktInternal::Optional<types::NumberConstant> types::CheckedNumericConstant::number_constant() const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("lhs: {}", that.lhs));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("op: {}", that.op));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("rhs: {}", that.rhs));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::NumberConstant>, JaktInternal::Optional<types::NumberConstant>>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I8>();
+i8 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((value)))) } );
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I16>();
+i16 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((value)))) } );
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I32>();
+i32 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((value)))) } );
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I64>();
+i64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((value)))) } );
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U8>();
+u8 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U16>();
+u16 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U32>();
+u32 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U64>();
+u64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::USize>();
+u64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F64>();
+f64 const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Floating(value) } );
+};/*case end*/
+default: {
+return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+};/*case end*/
+}/*switch end*/
+}()
+)));
 }
-TRY(builder.append(")"sv));
+}
+
+ErrorOr<DeprecatedString> types::CheckedCapture::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* ByValue */: {
+return DeprecatedString("CheckedCapture::ByValue"sv);
+break;}
+case 1 /* ByReference */: {
+return DeprecatedString("CheckedCapture::ByReference"sv);
+break;}
+case 2 /* ByMutableReference */: {
+return DeprecatedString("CheckedCapture::ByMutableReference"sv);
+break;}
+case 3 /* ByComptimeDependency */: {
+return DeprecatedString("CheckedCapture::ByComptimeDependency"sv);
+break;}
+case 4 /* AllByReference */: {
+return DeprecatedString("CheckedCapture::AllByReference"sv);
 break;}
-case 8 /* JaktTuple */: {
-TRY(builder.append("CheckedExpression::JaktTuple"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::JaktTuple>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("vals: {}", that.vals));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
 }
-TRY(builder.append(")"sv));
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> types::StructOrEnumId::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Struct */: {
+TRY(builder.append("StructOrEnumId::Struct"sv));
+[[maybe_unused]] auto const& that = this->template get<StructOrEnumId::Struct>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 1 /* Enum */: {
+TRY(builder.append("StructOrEnumId::Enum"sv));
+[[maybe_unused]] auto const& that = this->template get<StructOrEnumId::Enum>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 9 /* Range */: {
-TRY(builder.append("CheckedExpression::Range"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Range>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("from: {}", that.from));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("to: {}", that.to));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
 }
-TRY(builder.append(")"sv));
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> types::SafetyMode::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Safe */: {
+return DeprecatedString("SafetyMode::Safe"sv);
+break;}
+case 1 /* Unsafe */: {
+return DeprecatedString("SafetyMode::Unsafe"sv);
 break;}
-case 10 /* JaktArray */: {
-TRY(builder.append("CheckedExpression::JaktArray"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::JaktArray>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("vals: {}", that.vals));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("repeat: {}", that.repeat));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner_type_id: {}", that.inner_type_id));
 }
-TRY(builder.append(")"sv));
+return builder.to_string();
+}
+ErrorOr<DeprecatedString> types::MaybeResolvedScope::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Resolved */: {
+TRY(builder.append("MaybeResolvedScope::Resolved"sv));
+[[maybe_unused]] auto const& that = this->template get<MaybeResolvedScope::Resolved>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 11 /* JaktSet */: {
-TRY(builder.append("CheckedExpression::JaktSet"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::JaktSet>();
+case 1 /* Unresolved */: {
+TRY(builder.append("MaybeResolvedScope::Unresolved"sv));
+[[maybe_unused]] auto const& that = this->template get<MaybeResolvedScope::Unresolved>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("vals: {}", that.vals));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
+TRY(builder.appendff("parent_scope: {}", that.parent_scope));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner_type_id: {}", that.inner_type_id));
+TRY(builder.appendff("relative_name: \"{}\"", that.relative_name));
 }
 TRY(builder.append(")"sv));
 break;}
-case 12 /* JaktDictionary */: {
-TRY(builder.append("CheckedExpression::JaktDictionary"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::JaktDictionary>();
-TRY(builder.append("("sv));
+}
+return builder.to_string();
+}
+ErrorOr<NonnullRefPtr<typename types::MaybeResolvedScope>> types::MaybeResolvedScope::try_resolve(NonnullRefPtr<types::CheckedProgram> const program) const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("vals: {}", that.vals));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("key_type_id: {}", that.key_type_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("value_type_id: {}", that.value_type_id));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<NonnullRefPtr<typename types::MaybeResolvedScope>, ErrorOr<NonnullRefPtr<typename types::MaybeResolvedScope>>>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::MaybeResolvedScope::Resolved>();
+types::ScopeId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Resolved>(id))));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::MaybeResolvedScope::Unresolved>();NonnullRefPtr<typename types::MaybeResolvedScope> const& parent_scope = __jakt_match_value.parent_scope;
+DeprecatedString const& relative_name = __jakt_match_value.relative_name;
+return JaktInternal::ExplicitValue(({ Optional<NonnullRefPtr<typename types::MaybeResolvedScope>> __jakt_var_144; {
+NonnullRefPtr<typename types::MaybeResolvedScope> parent = TRY((((parent_scope)->try_resolve(program))));
+if (((parent)->index() == 0 /* Resolved */)){
+types::ScopeId const parent_scope_id = ((parent)->get<types::MaybeResolvedScope::Resolved>()).value;
+types::ScopeId const scope = parent_scope_id;
+JaktInternal::Optional<types::ScopeId> scope_id = JaktInternal::OptionalNone();
+if ((!(((scope_id).has_value())))){
+JaktInternal::Optional<types::StructId> const struct_ = TRY((((program)->find_struct_in_scope(scope,relative_name))));
+if (((struct_).has_value())){
+(scope_id = ((((program)->get_struct((struct_.value())))).scope_id));
 }
-TRY(builder.append(")"sv));
+}
+if ((!(((scope_id).has_value())))){
+JaktInternal::Optional<types::EnumId> const enum_ = TRY((((program)->find_enum_in_scope(scope,relative_name))));
+if (((enum_).has_value())){
+(scope_id = ((((program)->get_enum((enum_.value())))).scope_id));
+}
+}
+if ((!(((scope_id).has_value())))){
+JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>> const ns = TRY((((program)->find_namespace_in_scope(scope,relative_name,false))));
+if (((ns).has_value())){
+(scope_id = (((ns.value())).template get<0>()));
+}
+}
+if ((!(((scope_id).has_value())))){
+JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>> const ids = TRY((((program)->find_functions_with_name_in_scope(scope,relative_name))));
+if (((ids).has_value())){
+(scope_id = ((((program)->get_function((((ids.value()))[static_cast<i64>(0LL)]))))->function_scope_id));
+}
+}
+if (((scope_id).has_value())){
+return (TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Resolved>((scope_id.value())))));
+}
+}
+__jakt_var_144 = TRY((types::MaybeResolvedScope::template __jakt_create<typename types::MaybeResolvedScope::Unresolved>(parent,relative_name))); goto __jakt_label_140;
+
+}
+__jakt_label_140:; __jakt_var_144.release_value(); }));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
+ErrorOr<DeprecatedString> types::StringLiteral::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Static */: {
+TRY(builder.append("StringLiteral::Static"sv));
+[[maybe_unused]] auto const& that = this->template get<StringLiteral::Static>();
+TRY(builder.appendff("(\"{}\")", that.value));
 break;}
-case 13 /* IndexedExpression */: {
-TRY(builder.append("CheckedExpression::IndexedExpression"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedExpression>();
-TRY(builder.append("("sv));
+}
+return builder.to_string();
+}
+DeprecatedString types::StringLiteral::to_string() const {
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: {}", that.index));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, DeprecatedString>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StringLiteral::Static>();
+DeprecatedString const& value = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(value);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
 }
-TRY(builder.append(")"sv));
+}
+
+ErrorOr<DeprecatedString> types::StructLikeId::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Struct */: {
+TRY(builder.append("StructLikeId::Struct"sv));
+[[maybe_unused]] auto const& that = this->template get<StructLikeId::Struct>();
+TRY(builder.appendff("({})", that.value));
 break;}
-case 14 /* IndexedDictionary */: {
-TRY(builder.append("CheckedExpression::IndexedDictionary"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedDictionary>();
-TRY(builder.append("("sv));
+case 1 /* Enum */: {
+TRY(builder.append("StructLikeId::Enum"sv));
+[[maybe_unused]] auto const& that = this->template get<StructLikeId::Enum>();
+TRY(builder.appendff("({})", that.value));
+break;}
+case 2 /* Trait */: {
+TRY(builder.append("StructLikeId::Trait"sv));
+[[maybe_unused]] auto const& that = this->template get<StructLikeId::Trait>();
+TRY(builder.appendff("({})", that.value));
+break;}
+}
+return builder.to_string();
+}
+ErrorOr<JaktInternal::DynamicArray<types::TypeId>> types::StructLikeId::generic_parameters(NonnullRefPtr<types::CheckedProgram> const& program) const {
+{
+JaktInternal::DynamicArray<types::CheckedGenericParameter> const parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::CheckedGenericParameter>, ErrorOr<JaktInternal::DynamicArray<types::TypeId>>>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Struct>();
+types::StructId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((((program)))->get_struct(id))).generic_parameters));
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Enum>();
+types::EnumId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((((program)))->get_enum(id))).generic_parameters));
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Trait>();
+types::TraitId const& id = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(((((((program)))->get_trait(id)))->generic_parameters));
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+));
+JaktInternal::DynamicArray<types::TypeId> result = (TRY((DynamicArray<types::TypeId>::create_with({}))));
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: {}", that.index));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
+JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((parameters).iterator());
+for (;;){
+JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-TRY(builder.append(")"sv));
-break;}
-case 15 /* IndexedTuple */: {
-TRY(builder.append("CheckedExpression::IndexedTuple"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedTuple>();
-TRY(builder.append("("sv));
+types::CheckedGenericParameter parameter = (_magic_value.value());
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: {}", that.index));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
+TRY((((result).push(((parameter).type_id)))));
 }
-TRY(builder.append(")"sv));
-break;}
-case 16 /* IndexedStruct */: {
-TRY(builder.append("CheckedExpression::IndexedStruct"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedStruct>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: \"{}\"", that.index));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
+
 }
-TRY(builder.append(")"sv));
-break;}
-case 17 /* IndexedCommonEnumMember */: {
-TRY(builder.append("CheckedExpression::IndexedCommonEnumMember"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedCommonEnumMember>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: \"{}\"", that.index));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
 }
-TRY(builder.append(")"sv));
-break;}
-case 18 /* ComptimeIndex */: {
-TRY(builder.append("CheckedExpression::ComptimeIndex"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::ComptimeIndex>();
+
+return (result);
+}
+}
+
+ErrorOr<DeprecatedString> types::CheckedExpression::debug_description() const {
+auto builder = TRY(DeprecatedStringBuilder::create());
+switch (this->index()) {case 0 /* Boolean */: {
+TRY(builder.append("CheckedExpression::Boolean"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Boolean>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("index: {}", that.index));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.appendff("val: {}", that.val));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 19 /* Match */: {
-TRY(builder.append("CheckedExpression::Match"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Match>();
+case 1 /* NumericConstant */: {
+TRY(builder.append("CheckedExpression::NumericConstant"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::NumericConstant>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("match_cases: {}", that.match_cases));
+TRY(builder.appendff("val: {}", that.val));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("type_id: {}", that.type_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("all_variants_constant: {}", that.all_variants_constant));
 }
 TRY(builder.append(")"sv));
 break;}
-case 20 /* EnumVariantArg */: {
-TRY(builder.append("CheckedExpression::EnumVariantArg"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::EnumVariantArg>();
+case 2 /* QuotedString */: {
+TRY(builder.append("CheckedExpression::QuotedString"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::QuotedString>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("arg: {}", that.arg));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("enum_variant: {}", that.enum_variant));
+TRY(builder.appendff("val: {}", that.val));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 21 /* Call */: {
-TRY(builder.append("CheckedExpression::Call"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Call>();
+case 3 /* ByteConstant */: {
+TRY(builder.append("CheckedExpression::ByteConstant"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::ByteConstant>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("call: {}", that.call));
+TRY(builder.appendff("val: \"{}\"", that.val));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 22 /* MethodCall */: {
-TRY(builder.append("CheckedExpression::MethodCall"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::MethodCall>();
+case 4 /* CharacterConstant */: {
+TRY(builder.append("CheckedExpression::CharacterConstant"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::CharacterConstant>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("call: {}", that.call));
+TRY(builder.appendff("val: \"{}\"", that.val));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("is_optional: {}", that.is_optional));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 23 /* NamespacedVar */: {
-TRY(builder.append("CheckedExpression::NamespacedVar"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::NamespacedVar>();
+case 5 /* CCharacterConstant */: {
+TRY(builder.append("CheckedExpression::CCharacterConstant"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::CCharacterConstant>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("namespaces: {}", that.namespaces));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("var: {}", that.var));
+TRY(builder.appendff("val: \"{}\"", that.val));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 }
 TRY(builder.append(")"sv));
 break;}
-case 24 /* Var */: {
-TRY(builder.append("CheckedExpression::Var"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Var>();
+case 6 /* UnaryOp */: {
+TRY(builder.append("CheckedExpression::UnaryOp"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::UnaryOp>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("var: {}", that.var));
+TRY(builder.appendff("expr: {}", that.expr));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
-}
-TRY(builder.append(")"sv));
-break;}
-case 25 /* OptionalNone */: {
-TRY(builder.append("CheckedExpression::OptionalNone"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::OptionalNone>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(builder.appendff("op: {}", that.op));
+TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 TRY(builder.append(", "sv));
@@ -6421,31 +6308,20 @@ TRY(builder.appendff("type_id: {}", that.type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 26 /* OptionalSome */: {
-TRY(builder.append("CheckedExpression::OptionalSome"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::OptionalSome>();
+case 7 /* BinaryOp */: {
+TRY(builder.append("CheckedExpression::BinaryOp"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::BinaryOp>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.appendff("lhs: {}", that.lhs));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+TRY(builder.appendff("op: {}", that.op));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type_id: {}", that.type_id));
-}
-TRY(builder.append(")"sv));
-break;}
-case 27 /* ForcedUnwrap */: {
-TRY(builder.append("CheckedExpression::ForcedUnwrap"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::ForcedUnwrap>();
-TRY(builder.append("("sv));
-{
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.appendff("rhs: {}", that.rhs));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
@@ -6455,14 +6331,14 @@ TRY(builder.appendff("type_id: {}", that.type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 28 /* Block */: {
-TRY(builder.append("CheckedExpression::Block"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Block>();
+case 8 /* JaktTuple */: {
+TRY(builder.append("CheckedExpression::JaktTuple"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::JaktTuple>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("vals: {}", that.vals));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
@@ -6472,61 +6348,57 @@ TRY(builder.appendff("type_id: {}", that.type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 29 /* Function */: {
-TRY(builder.append("CheckedExpression::Function"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Function>();
+case 9 /* Range */: {
+TRY(builder.append("CheckedExpression::Range"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Range>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("captures: {}", that.captures));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("params: {}", that.params));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("can_throw: {}", that.can_throw));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("return_type_id: {}", that.return_type_id));
+TRY(builder.appendff("from: {}", that.from));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("to: {}", that.to));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("type_id: {}", that.type_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("pseudo_function_id: {}", that.pseudo_function_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("scope_id: {}", that.scope_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 30 /* DependentFunction */: {
-TRY(builder.append("CheckedExpression::DependentFunction"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::DependentFunction>();
+case 10 /* JaktArray */: {
+TRY(builder.append("CheckedExpression::JaktArray"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::JaktArray>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("captures: {}", that.captures));
+TRY(builder.appendff("vals: {}", that.vals));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("params: {}", that.params));
+TRY(builder.appendff("repeat: {}", that.repeat));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("can_throw: {}", that.can_throw));
+TRY(builder.appendff("span: {}", that.span));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("return_type_id: {}", that.return_type_id));
+TRY(builder.appendff("type_id: {}", that.type_id));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("block: {}", that.block));
+TRY(builder.appendff("inner_type_id: {}", that.inner_type_id));
+}
+TRY(builder.append(")"sv));
+break;}
+case 11 /* JaktSet */: {
+TRY(builder.append("CheckedExpression::JaktSet"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::JaktSet>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("vals: {}", that.vals));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
@@ -6535,27 +6407,18 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("type_id: {}", that.type_id));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("pseudo_function_id: {}", that.pseudo_function_id));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("scope_id: {}", that.scope_id));
+TRY(builder.appendff("inner_type_id: {}", that.inner_type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 31 /* Try */: {
-TRY(builder.append("CheckedExpression::Try"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Try>();
+case 12 /* JaktDictionary */: {
+TRY(builder.append("CheckedExpression::JaktDictionary"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::JaktDictionary>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("expr: {}", that.expr));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("catch_block: {}", that.catch_block));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("catch_name: {}", that.catch_name));
+TRY(builder.appendff("vals: {}", that.vals));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
@@ -6564,27 +6427,24 @@ TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("type_id: {}", that.type_id));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("inner_type_id: {}", that.inner_type_id));
+TRY(builder.appendff("key_type_id: {}", that.key_type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("value_type_id: {}", that.value_type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 32 /* TryBlock */: {
-TRY(builder.append("CheckedExpression::TryBlock"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::TryBlock>();
+case 13 /* IndexedExpression */: {
+TRY(builder.append("CheckedExpression::IndexedExpression"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedExpression>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("stmt: {}", that.stmt));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("catch_block: {}", that.catch_block));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("error_name: \"{}\"", that.error_name));
+TRY(builder.appendff("expr: {}", that.expr));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("error_span: {}", that.error_span));
+TRY(builder.appendff("index: {}", that.index));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
@@ -6594,14 +6454,17 @@ TRY(builder.appendff("type_id: {}", that.type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 33 /* Reflect */: {
-TRY(builder.append("CheckedExpression::Reflect"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Reflect>();
+case 14 /* IndexedDictionary */: {
+TRY(builder.append("CheckedExpression::IndexedDictionary"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedDictionary>();
 TRY(builder.append("("sv));
 {
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("type: {}", that.type));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: {}", that.index));
 TRY(builder.append(", "sv));
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));
 TRY(builder.appendff("span: {}", that.span));
@@ -6611,357 +6474,433 @@ TRY(builder.appendff("type_id: {}", that.type_id));
 }
 TRY(builder.append(")"sv));
 break;}
-case 34 /* Garbage */: {
-TRY(builder.append("CheckedExpression::Garbage"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Garbage>();
-TRY(builder.appendff("({})", that.value));
-break;}
-}
-return builder.to_string();
-}
-utility::Span types::CheckedExpression::span() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NumericConstant>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::QuotedString>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ByteConstant>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CharacterConstant>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CCharacterConstant>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktTuple>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 9: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Range>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 17: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ComptimeIndex>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 19: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Match>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 20: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::EnumVariantArg>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 23: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NamespacedVar>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 25: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalNone>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 26: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalSome>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 28: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Block>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 29: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Function>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 30: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::DependentFunction>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 31: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Try>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 32: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::TryBlock>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 33: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Reflect>();utility::Span const& span = __jakt_match_value.span;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-case 34: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedExpression::Garbage>();
-utility::Span const& span = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(span);
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
-}
-}
-
-bool types::CheckedExpression::can_throw() const {
+case 15 /* IndexedTuple */: {
+TRY(builder.append("CheckedExpression::IndexedTuple"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedTuple>();
+TRY(builder.append("("sv));
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 21: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
-return JaktInternal::ExplicitValue(((call).callee_throws));
-};/*case end*/
-case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();types::CheckedCall const& call = __jakt_match_value.call;
-return JaktInternal::ExplicitValue(((call).callee_throws));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: {}", that.index));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
+TRY(builder.append(")"sv));
+break;}
+case 16 /* IndexedStruct */: {
+TRY(builder.append("CheckedExpression::IndexedStruct"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedStruct>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: \"{}\"", that.index));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
-
-bool types::CheckedExpression::is_mutable(NonnullRefPtr<types::CheckedProgram> const program) const {
+TRY(builder.append(")"sv));
+break;}
+case 17 /* IndexedCommonEnumMember */: {
+TRY(builder.append("CheckedExpression::IndexedCommonEnumMember"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::IndexedCommonEnumMember>();
+TRY(builder.append("("sv));
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 1: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 2: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 3: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 4: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 5: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 24: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
-return JaktInternal::ExplicitValue(((var)->is_mutable));
-};/*case end*/
-case 16: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
-};/*case end*/
-case 13: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
-};/*case end*/
-case 18: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ComptimeIndex>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
-};/*case end*/
-case 15: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
-};/*case end*/
-case 14: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
-};/*case end*/
-case 27: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
-};/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_145; {
-bool result = false;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: \"{}\"", that.index));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
+}
+TRY(builder.append(")"sv));
+break;}
+case 18 /* ComptimeIndex */: {
+TRY(builder.append("CheckedExpression::ComptimeIndex"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::ComptimeIndex>();
+TRY(builder.append("("sv));
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("index: {}", that.index));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
+TRY(builder.append(")"sv));
+break;}
+case 19 /* Match */: {
+TRY(builder.append("CheckedExpression::Match"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Match>();
+TRY(builder.append("("sv));
 {
-if (((val)->is_mutable(program))){
-(result = true);
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("match_cases: {}", that.match_cases));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("all_variants_constant: {}", that.all_variants_constant));
 }
+TRY(builder.append(")"sv));
+break;}
+case 20 /* EnumVariantArg */: {
+TRY(builder.append("CheckedExpression::EnumVariantArg"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::EnumVariantArg>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("arg: {}", that.arg));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("enum_variant: {}", that.enum_variant));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-
+TRY(builder.append(")"sv));
+break;}
+case 21 /* Call */: {
+TRY(builder.append("CheckedExpression::Call"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Call>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("call: {}", that.call));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
+TRY(builder.append(")"sv));
+break;}
+case 22 /* MethodCall */: {
+TRY(builder.append("CheckedExpression::MethodCall"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::MethodCall>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("call: {}", that.call));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("is_optional: {}", that.is_optional));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
-
-__jakt_var_145 = result; goto __jakt_label_141;
-
+TRY(builder.append(")"sv));
+break;}
+case 23 /* NamespacedVar */: {
+TRY(builder.append("CheckedExpression::NamespacedVar"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::NamespacedVar>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("namespaces: {}", that.namespaces));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("var: {}", that.var));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-__jakt_label_141:; __jakt_var_145.release_value(); }));
-};/*case end*/
-case 11: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_146; {
-bool result = false;
+TRY(builder.append(")"sv));
+break;}
+case 24 /* Var */: {
+TRY(builder.append("CheckedExpression::Var"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Var>();
+TRY(builder.append("("sv));
 {
-JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("var: {}", that.var));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
 }
-NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
+TRY(builder.append(")"sv));
+break;}
+case 25 /* OptionalNone */: {
+TRY(builder.append("CheckedExpression::OptionalNone"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::OptionalNone>();
+TRY(builder.append("("sv));
 {
-if (((val)->is_mutable(program))){
-(result = true);
-break;
-}
-}
-
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
+TRY(builder.append(")"sv));
+break;}
+case 26 /* OptionalSome */: {
+TRY(builder.append("CheckedExpression::OptionalSome"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::OptionalSome>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
-
-__jakt_var_146 = result; goto __jakt_label_142;
-
+TRY(builder.append(")"sv));
+break;}
+case 27 /* ForcedUnwrap */: {
+TRY(builder.append("CheckedExpression::ForcedUnwrap"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::ForcedUnwrap>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
-__jakt_label_142:; __jakt_var_146.release_value(); }));
-};/*case end*/
-case 12: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
-return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_147; {
-bool result = false;
+TRY(builder.append(")"sv));
+break;}
+case 28 /* Block */: {
+TRY(builder.append("CheckedExpression::Block"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Block>();
+TRY(builder.append("("sv));
 {
-JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
-for (;;){
-JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("block: {}", that.block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
-JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> ___val__ = (_magic_value.value());
+TRY(builder.append(")"sv));
+break;}
+case 29 /* Function */: {
+TRY(builder.append("CheckedExpression::Function"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Function>();
+TRY(builder.append("("sv));
 {
-JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> const jakt_____val__ = ___val__;
-NonnullRefPtr<typename types::CheckedExpression> const _ = ((jakt_____val__).template get<0>());
-NonnullRefPtr<typename types::CheckedExpression> const val = ((jakt_____val__).template get<1>());
-
-if (((val)->is_mutable(program))){
-(result = true);
-break;
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("captures: {}", that.captures));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("params: {}", that.params));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("can_throw: {}", that.can_throw));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("return_type_id: {}", that.return_type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("block: {}", that.block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("pseudo_function_id: {}", that.pseudo_function_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("scope_id: {}", that.scope_id));
 }
+TRY(builder.append(")"sv));
+break;}
+case 30 /* DependentFunction */: {
+TRY(builder.append("CheckedExpression::DependentFunction"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::DependentFunction>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("captures: {}", that.captures));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("params: {}", that.params));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("can_throw: {}", that.can_throw));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("return_type_id: {}", that.return_type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("block: {}", that.block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("pseudo_function_id: {}", that.pseudo_function_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("scope_id: {}", that.scope_id));
 }
-
+TRY(builder.append(")"sv));
+break;}
+case 31 /* Try */: {
+TRY(builder.append("CheckedExpression::Try"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Try>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("expr: {}", that.expr));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("catch_block: {}", that.catch_block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("catch_name: {}", that.catch_name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("inner_type_id: {}", that.inner_type_id));
 }
+TRY(builder.append(")"sv));
+break;}
+case 32 /* TryBlock */: {
+TRY(builder.append("CheckedExpression::TryBlock"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::TryBlock>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("stmt: {}", that.stmt));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("catch_block: {}", that.catch_block));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("error_name: \"{}\"", that.error_name));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("error_span: {}", that.error_span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
-
-__jakt_var_147 = result; goto __jakt_label_143;
-
+TRY(builder.append(")"sv));
+break;}
+case 33 /* Reflect */: {
+TRY(builder.append("CheckedExpression::Reflect"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Reflect>();
+TRY(builder.append("("sv));
+{
+JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type: {}", that.type));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("span: {}", that.span));
+TRY(builder.append(", "sv));
+TRY(JaktInternal::PrettyPrint::output_indentation(builder));
+TRY(builder.appendff("type_id: {}", that.type_id));
 }
-__jakt_label_143:; __jakt_var_147.release_value(); }));
-};/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-types::CheckedUnaryOperator const& op = __jakt_match_value.op;
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = op;
-switch(__jakt_match_variant.index()) {
-case 5: {
-return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
-auto&& __jakt_match_variant = *((program)->get_type(((expr)->type())));
-switch(__jakt_match_variant.index()) {
-case 28: {
-return JaktInternal::ExplicitValue(true);
-};/*case end*/
-case 25: {
-return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
-};/*case end*/
-default: {
-return JaktInternal::ExplicitValue(false);
-};/*case end*/
-}/*switch end*/
-}()
-)));
+TRY(builder.append(")"sv));
+break;}
+case 34 /* Garbage */: {
+TRY(builder.append("CheckedExpression::Garbage"sv));
+[[maybe_unused]] auto const& that = this->template get<CheckedExpression::Garbage>();
+TRY(builder.appendff("({})", that.value));
+break;}
+}
+return builder.to_string();
+}
+bool types::CheckedExpression::can_throw() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();types::CheckedCall const& call = __jakt_match_value.call;
+return JaktInternal::ExplicitValue(((call).callee_throws));
 };/*case end*/
 case 22: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
-return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();types::CheckedCall const& call = __jakt_match_value.call;
+return JaktInternal::ExplicitValue(((call).callee_throws));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(false);
@@ -6988,12 +6927,12 @@ auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpr
 types::CheckedUnaryOperator const& op = __jakt_match_value.op;
 utility::Span const& span = __jakt_match_value.span;
 types::TypeId const& type_id = __jakt_match_value.type_id;
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::NumberConstant>> __jakt_var_148; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::NumberConstant>> __jakt_var_145; {
 JaktInternal::Optional<types::NumberConstant> result = JaktInternal::OptionalNone();
-__jakt_var_148 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::NumberConstant>,JaktInternal::Optional<types::NumberConstant>>{
+__jakt_var_145 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::NumberConstant>,JaktInternal::Optional<types::NumberConstant>>{
 auto __jakt_enum_value = (((op).index() == 11 /* TypeCast */));
 if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::NumberConstant>> __jakt_var_149; {
+return JaktInternal::ExplicitValue(({ Optional<JaktInternal::Optional<types::NumberConstant>> __jakt_var_146; {
 types::CheckedTypeCast const cast = ((op).get<types::CheckedUnaryOperator::TypeCast>()).value;
 if ((!(((cast).index() == 1 /* Infallible */)))){
 (result = JaktInternal::OptionalNone());
@@ -7005,10 +6944,10 @@ if (((expr)->index() == 1 /* NumericConstant */)){
 types::CheckedNumericConstant const val = ((expr)->get<types::CheckedExpression::NumericConstant>()).val;
 (result = ((val).number_constant()));
 }
-__jakt_var_149 = result; goto __jakt_label_145;
+__jakt_var_146 = result; goto __jakt_label_142;
 
 }
-__jakt_label_145:; __jakt_var_149.release_value(); }));
+__jakt_label_142:; __jakt_var_146.release_value(); }));
 }
 else {
 {
@@ -7016,10 +6955,10 @@ return (JaktInternal::OptionalNone());
 }
 }
 }()))
-; goto __jakt_label_144;
+; goto __jakt_label_141;
 
 }
-__jakt_label_144:; __jakt_var_148.release_value(); }));
+__jakt_label_141:; __jakt_var_145.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
@@ -7030,6 +6969,158 @@ return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
 }
 }
 
+utility::Span types::CheckedExpression::span() const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<utility::Span, utility::Span>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Boolean>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 1: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NumericConstant>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 2: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::QuotedString>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 3: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ByteConstant>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 4: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CharacterConstant>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 5: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::CCharacterConstant>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 7: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::BinaryOp>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 8: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktTuple>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 9: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Range>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 17: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedCommonEnumMember>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ComptimeIndex>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 19: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Match>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 20: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::EnumVariantArg>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 21: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Call>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 23: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::NamespacedVar>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 25: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalNone>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 26: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::OptionalSome>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 28: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Block>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 29: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Function>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 30: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::DependentFunction>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 31: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Try>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 32: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::TryBlock>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 33: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Reflect>();utility::Span const& span = __jakt_match_value.span;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+case 34: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedExpression::Garbage>();
+utility::Span const& span = __jakt_match_value.value;
+return JaktInternal::ExplicitValue(span);
+};/*case end*/
+default: VERIFY_NOT_REACHED();}/*switch end*/
+}()
+)));
+}
+}
+
 types::TypeId types::CheckedExpression::type() const {
 {
 return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::TypeId, types::TypeId>{
@@ -7186,7 +7277,7 @@ JaktInternal::DynamicArray<types::CheckedMatchCase> const& match_cases = __jakt_
 utility::Span const& span = __jakt_match_value.span;
 types::TypeId const& type_id = __jakt_match_value.type_id;
 bool const& all_variants_constant = __jakt_match_value.all_variants_constant;
-return JaktInternal::ExplicitValue(({ Optional<types::BlockControlFlow> __jakt_var_150; {
+return JaktInternal::ExplicitValue(({ Optional<types::BlockControlFlow> __jakt_var_147; {
 JaktInternal::Optional<types::BlockControlFlow> control_flow = JaktInternal::OptionalNone();
 {
 JaktInternal::ArrayIterator<types::CheckedMatchCase> _magic = ((match_cases).iterator());
@@ -7272,10 +7363,10 @@ else {
 }
 }
 
-__jakt_var_150 = control_flow.value_or_lazy_evaluated([&] { return  types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ; }); goto __jakt_label_146;
+__jakt_var_147 = control_flow.value_or_lazy_evaluated([&] { return  types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } ; }); goto __jakt_label_143;
 
 }
-__jakt_label_146:; __jakt_var_150.release_value(); }));
+__jakt_label_143:; __jakt_var_147.release_value(); }));
 };/*case end*/
 case 22: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();types::TypeId const& type_id = __jakt_match_value.type_id;
@@ -7306,16 +7397,16 @@ return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::Bl
 case 32: {
 auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::TryBlock>();NonnullRefPtr<typename types::CheckedStatement> const& stmt = __jakt_match_value.stmt;
 types::CheckedBlock const& catch_block = __jakt_match_value.catch_block;
-return JaktInternal::ExplicitValue(({ Optional<types::BlockControlFlow> __jakt_var_151; {
-__jakt_var_151 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
+return JaktInternal::ExplicitValue(({ Optional<types::BlockControlFlow> __jakt_var_148; {
+__jakt_var_148 = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<types::BlockControlFlow,types::BlockControlFlow>{
 auto __jakt_enum_value = (((stmt)->index() == 5 /* Block */));
 if (__jakt_enum_value == true) {
-return JaktInternal::ExplicitValue(({ Optional<types::BlockControlFlow> __jakt_var_152; {
+return JaktInternal::ExplicitValue(({ Optional<types::BlockControlFlow> __jakt_var_149; {
 types::CheckedBlock const block = ((stmt)->get<types::CheckedStatement::Block>()).block;
-__jakt_var_152 = ((((block).control_flow)).branch_unify_with(((catch_block).control_flow))); goto __jakt_label_148;
+__jakt_var_149 = ((((block).control_flow)).branch_unify_with(((catch_block).control_flow))); goto __jakt_label_145;
 
 }
-__jakt_label_148:; __jakt_var_152.release_value(); }));
+__jakt_label_145:; __jakt_var_149.release_value(); }));
 }
 else {
 {
@@ -7323,10 +7414,10 @@ utility::panic(Jakt::DeprecatedString("Try block doesn't have a block"sv));
 }
 }
 }()))
-; goto __jakt_label_147;
+; goto __jakt_label_144;
 
 }
-__jakt_label_147:; __jakt_var_151.release_value(); }));
+__jakt_label_144:; __jakt_var_148.release_value(); }));
 };/*case end*/
 default: {
 return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::BlockControlFlow::MayReturn() } );
@@ -7337,237 +7428,178 @@ return JaktInternal::ExplicitValue( types::BlockControlFlow { typename types::Bl
 }
 }
 
-ErrorOr<DeprecatedString> types::StringLiteral::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Static */: {
-TRY(builder.append("StringLiteral::Static"sv));
-[[maybe_unused]] auto const& that = this->template get<StringLiteral::Static>();
-TRY(builder.appendff("(\"{}\")", that.value));
-break;}
-}
-return builder.to_string();
+bool types::CheckedExpression::is_mutable(NonnullRefPtr<types::CheckedProgram> const program) const {
+{
+return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *this;
+switch(__jakt_match_variant.index()) {
+case 0: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 1: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 2: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 3: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 4: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 5: {
+return JaktInternal::ExplicitValue(true);
+};/*case end*/
+case 24: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::Var>();NonnullRefPtr<types::CheckedVariable> const& var = __jakt_match_value.var;
+return JaktInternal::ExplicitValue(((var)->is_mutable));
+};/*case end*/
+case 16: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedStruct>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
+};/*case end*/
+case 13: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedExpression>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
+};/*case end*/
+case 18: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ComptimeIndex>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
+};/*case end*/
+case 15: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedTuple>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
+};/*case end*/
+case 14: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::IndexedDictionary>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
+};/*case end*/
+case 27: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::ForcedUnwrap>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
+};/*case end*/
+case 10: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktArray>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_150; {
+bool result = false;
+{
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
+for (;;){
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-DeprecatedString types::StringLiteral::to_string() const {
+NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
 {
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<DeprecatedString, DeprecatedString>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StringLiteral::Static>();
-DeprecatedString const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(value);
-};/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-)));
+if (((val)->is_mutable(program))){
+(result = true);
+break;
 }
 }
 
-ErrorOr<DeprecatedString> types::StructLikeId::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Struct */: {
-TRY(builder.append("StructLikeId::Struct"sv));
-[[maybe_unused]] auto const& that = this->template get<StructLikeId::Struct>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* Enum */: {
-TRY(builder.append("StructLikeId::Enum"sv));
-[[maybe_unused]] auto const& that = this->template get<StructLikeId::Enum>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 2 /* Trait */: {
-TRY(builder.append("StructLikeId::Trait"sv));
-[[maybe_unused]] auto const& that = this->template get<StructLikeId::Trait>();
-TRY(builder.appendff("({})", that.value));
-break;}
 }
-return builder.to_string();
 }
-ErrorOr<JaktInternal::DynamicArray<types::TypeId>> types::StructLikeId::generic_parameters(NonnullRefPtr<types::CheckedProgram> const& program) const {
-{
-JaktInternal::DynamicArray<types::CheckedGenericParameter> const parameters = JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::DynamicArray<types::CheckedGenericParameter>, ErrorOr<JaktInternal::DynamicArray<types::TypeId>>>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Struct>();
-types::StructId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((((((program)))->get_struct(id))).generic_parameters));
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Enum>();
-types::EnumId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((((((program)))->get_enum(id))).generic_parameters));
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::StructLikeId::Trait>();
-types::TraitId const& id = __jakt_match_value.value;
-return JaktInternal::ExplicitValue(((((((program)))->get_trait(id)))->generic_parameters));
+
+__jakt_var_150 = result; goto __jakt_label_146;
+
+}
+__jakt_label_146:; __jakt_var_150.release_value(); }));
 };/*case end*/
-default: VERIFY_NOT_REACHED();}/*switch end*/
-}()
-));
-JaktInternal::DynamicArray<types::TypeId> result = (TRY((DynamicArray<types::TypeId>::create_with({}))));
+case 11: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktSet>();JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedExpression>> const& vals = __jakt_match_value.vals;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_151; {
+bool result = false;
 {
-JaktInternal::ArrayIterator<types::CheckedGenericParameter> _magic = ((parameters).iterator());
+JaktInternal::ArrayIterator<NonnullRefPtr<typename types::CheckedExpression>> _magic = ((vals).iterator());
 for (;;){
-JaktInternal::Optional<types::CheckedGenericParameter> const _magic_value = ((_magic).next());
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-types::CheckedGenericParameter parameter = (_magic_value.value());
+NonnullRefPtr<typename types::CheckedExpression> val = (_magic_value.value());
 {
-TRY((((result).push(((parameter).type_id)))));
+if (((val)->is_mutable(program))){
+(result = true);
+break;
+}
 }
 
 }
 }
 
-return (result);
+__jakt_var_151 = result; goto __jakt_label_147;
+
 }
+__jakt_label_147:; __jakt_var_151.release_value(); }));
+};/*case end*/
+case 12: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::JaktDictionary>();JaktInternal::DynamicArray<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const& vals = __jakt_match_value.vals;
+return JaktInternal::ExplicitValue(({ Optional<bool> __jakt_var_152; {
+bool result = false;
+{
+JaktInternal::ArrayIterator<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> _magic = ((vals).iterator());
+for (;;){
+JaktInternal::Optional<JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>>> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
 }
-
-ErrorOr<DeprecatedString> types::CheckedVisibility::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* Public */: {
-return DeprecatedString("CheckedVisibility::Public"sv);
-break;}
-case 1 /* Private */: {
-return DeprecatedString("CheckedVisibility::Private"sv);
-break;}
-case 2 /* Restricted */: {
-TRY(builder.append("CheckedVisibility::Restricted"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedVisibility::Restricted>();
-TRY(builder.append("("sv));
+JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> ___val__ = (_magic_value.value());
 {
-JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("scopes: {}", that.scopes));
-TRY(builder.append(", "sv));
-TRY(JaktInternal::PrettyPrint::output_indentation(builder));
-TRY(builder.appendff("span: {}", that.span));
+JaktInternal::Tuple<NonnullRefPtr<typename types::CheckedExpression>,NonnullRefPtr<typename types::CheckedExpression>> const jakt_____val__ = ___val__;
+NonnullRefPtr<typename types::CheckedExpression> const _ = ((jakt_____val__).template get<0>());
+NonnullRefPtr<typename types::CheckedExpression> const val = ((jakt_____val__).template get<1>());
+
+if (((val)->is_mutable(program))){
+(result = true);
+break;
 }
-TRY(builder.append(")"sv));
-break;}
 }
-return builder.to_string();
+
 }
-ErrorOr<DeprecatedString> types::CheckedNumericConstant::debug_description() const {
-auto builder = TRY(DeprecatedStringBuilder::create());
-switch (this->index()) {case 0 /* I8 */: {
-TRY(builder.append("CheckedNumericConstant::I8"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::I8>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 1 /* I16 */: {
-TRY(builder.append("CheckedNumericConstant::I16"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::I16>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 2 /* I32 */: {
-TRY(builder.append("CheckedNumericConstant::I32"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::I32>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 3 /* I64 */: {
-TRY(builder.append("CheckedNumericConstant::I64"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::I64>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 4 /* U8 */: {
-TRY(builder.append("CheckedNumericConstant::U8"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::U8>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 5 /* U16 */: {
-TRY(builder.append("CheckedNumericConstant::U16"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::U16>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 6 /* U32 */: {
-TRY(builder.append("CheckedNumericConstant::U32"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::U32>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 7 /* U64 */: {
-TRY(builder.append("CheckedNumericConstant::U64"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::U64>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 8 /* USize */: {
-TRY(builder.append("CheckedNumericConstant::USize"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::USize>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 9 /* F32 */: {
-TRY(builder.append("CheckedNumericConstant::F32"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::F32>();
-TRY(builder.appendff("({})", that.value));
-break;}
-case 10 /* F64 */: {
-TRY(builder.append("CheckedNumericConstant::F64"sv));
-[[maybe_unused]] auto const& that = this->template get<CheckedNumericConstant::F64>();
-TRY(builder.appendff("({})", that.value));
-break;}
 }
-return builder.to_string();
+
+__jakt_var_152 = result; goto __jakt_label_148;
+
 }
-JaktInternal::Optional<types::NumberConstant> types::CheckedNumericConstant::number_constant() const {
-{
-return (JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<JaktInternal::Optional<types::NumberConstant>, JaktInternal::Optional<types::NumberConstant>>{
-auto&& __jakt_match_variant = *this;
-switch(__jakt_match_variant.index()) {
-case 0: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I8>();
-i8 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((value)))) } );
-};/*case end*/
-case 1: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I16>();
-i16 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((value)))) } );
-};/*case end*/
-case 2: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I32>();
-i32 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((value)))) } );
+__jakt_label_148:; __jakt_var_152.release_value(); }));
 };/*case end*/
-case 3: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::I64>();
-i64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Signed((infallible_integer_cast<i64>((value)))) } );
+case 6: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::UnaryOp>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+types::CheckedUnaryOperator const& op = __jakt_match_value.op;
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = op;
+switch(__jakt_match_variant.index()) {
+case 5: {
+return JaktInternal::ExplicitValue(JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_RETURN_ONLY(([&]() -> JaktInternal::ExplicitValueOrControlFlow<bool, bool>{
+auto&& __jakt_match_variant = *((program)->get_type(((expr)->type())));
+switch(__jakt_match_variant.index()) {
+case 28: {
+return JaktInternal::ExplicitValue(true);
 };/*case end*/
-case 4: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U8>();
-u8 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+case 25: {
+return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
 };/*case end*/
-case 5: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U16>();
-u16 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 6: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U32>();
-u32 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 7: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::U64>();
-u64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+default: {
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
-case 8: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::USize>();
-u64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Unsigned((infallible_integer_cast<u64>((value)))) } );
+}/*switch end*/
+}()
+)));
 };/*case end*/
-case 10: {
-auto&& __jakt_match_value = __jakt_match_variant.template get<typename types::CheckedNumericConstant::F64>();
-f64 const& value = __jakt_match_value.value;
-return JaktInternal::ExplicitValue( types::NumberConstant { typename types::NumberConstant::Floating(value) } );
+case 22: {
+auto&& __jakt_match_value = __jakt_match_variant.template get<types::CheckedExpression::MethodCall>();NonnullRefPtr<typename types::CheckedExpression> const& expr = __jakt_match_value.expr;
+return JaktInternal::ExplicitValue(((expr)->is_mutable(program)));
 };/*case end*/
 default: {
-return JaktInternal::ExplicitValue(JaktInternal::OptionalNone());
+return JaktInternal::ExplicitValue(false);
 };/*case end*/
 }/*switch end*/
 }()
diff --git a/bootstrap/stage0/types.h b/bootstrap/stage0/types.h
index 441b2c1ba..9193ec5ef 100644
--- a/bootstrap/stage0/types.h
+++ b/bootstrap/stage0/types.h
@@ -7,9 +7,23 @@ namespace Jakt {
 namespace types {
 struct ModuleId {
   public:
-size_t id;ModuleId(size_t a_id);
+size_t id;bool equals(types::ModuleId const rhs) const;
+ModuleId(size_t a_id);
 
-bool equals(types::ModuleId const rhs) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};class Module : public RefCounted<Module>, public Weakable<Module> {
+  public:
+virtual ~Module() = default;
+types::ModuleId id;DeprecatedString name;JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> functions;JaktInternal::DynamicArray<types::CheckedStruct> structures;JaktInternal::DynamicArray<types::CheckedEnum> enums;JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> scopes;JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> types;JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> traits;JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> variables;JaktInternal::DynamicArray<types::ModuleId> imports;DeprecatedString resolved_import_path;bool is_root;types::FunctionId next_function_id() const;
+ErrorOr<types::FunctionId> add_function(NonnullRefPtr<types::CheckedFunction> const checked_function);
+bool is_prelude() const;
+protected:
+explicit Module(types::ModuleId a_id, DeprecatedString a_name, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> a_functions, JaktInternal::DynamicArray<types::CheckedStruct> a_structures, JaktInternal::DynamicArray<types::CheckedEnum> a_enums, JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> a_scopes, JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> a_types, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> a_traits, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> a_variables, JaktInternal::DynamicArray<types::ModuleId> a_imports, DeprecatedString a_resolved_import_path, bool a_is_root);
+public:
+static ErrorOr<NonnullRefPtr<Module>> __jakt_create(types::ModuleId id, DeprecatedString name, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> functions, JaktInternal::DynamicArray<types::CheckedStruct> structures, JaktInternal::DynamicArray<types::CheckedEnum> enums, JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> scopes, JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> types, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> traits, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> variables, JaktInternal::DynamicArray<types::ModuleId> imports, DeprecatedString resolved_import_path, bool is_root);
+
+ErrorOr<types::VarId> add_variable(NonnullRefPtr<types::CheckedVariable> const checked_variable);
+ErrorOr<types::TypeId> new_type_variable(JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const implemented_traits);
 ErrorOr<DeprecatedString> debug_description() const;
 };struct ScopeId {
   public:
@@ -17,6 +31,228 @@ types::ModuleId module_id;size_t id;ErrorOr<DeprecatedString> to_string() const;
 bool equals(types::ScopeId const other) const;
 ScopeId(types::ModuleId a_module_id, size_t a_id);
 
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace MaybeResolvedScope_Details {
+struct Resolved{
+types::ScopeId value;
+template<typename _MemberT0>
+Resolved(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct Unresolved {
+NonnullRefPtr<typename types::MaybeResolvedScope> parent_scope;
+DeprecatedString relative_name;
+template<typename _MemberT0, typename _MemberT1>
+Unresolved(_MemberT0&& member_0, _MemberT1&& member_1):
+parent_scope{ forward<_MemberT0>(member_0)},
+relative_name{ forward<_MemberT1>(member_1)}
+{}
+};
+}
+struct MaybeResolvedScope : public Variant<MaybeResolvedScope_Details::Resolved, MaybeResolvedScope_Details::Unresolved>, public RefCounted<MaybeResolvedScope> {
+using Variant<MaybeResolvedScope_Details::Resolved, MaybeResolvedScope_Details::Unresolved>::Variant;
+    using Resolved = MaybeResolvedScope_Details::Resolved;
+    using Unresolved = MaybeResolvedScope_Details::Unresolved;
+template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
+return adopt_nonnull_ref_or_enomem(new (nothrow) MaybeResolvedScope(V(forward<Args>(args)...)));
+}
+ErrorOr<DeprecatedString> debug_description() const;
+ErrorOr<NonnullRefPtr<typename types::MaybeResolvedScope>> try_resolve(NonnullRefPtr<types::CheckedProgram> const program) const;
+};
+namespace CheckedVisibility_Details {
+struct Public {
+};
+struct Private {
+};
+struct Restricted {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> scopes;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Restricted(_MemberT0&& member_0, _MemberT1&& member_1):
+scopes{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+}
+struct CheckedVisibility : public Variant<CheckedVisibility_Details::Public, CheckedVisibility_Details::Private, CheckedVisibility_Details::Restricted> {
+using Variant<CheckedVisibility_Details::Public, CheckedVisibility_Details::Private, CheckedVisibility_Details::Restricted>::Variant;
+    using Public = CheckedVisibility_Details::Public;
+    using Private = CheckedVisibility_Details::Private;
+    using Restricted = CheckedVisibility_Details::Restricted;
+ErrorOr<DeprecatedString> debug_description() const;
+};
+struct TypeId {
+  public:
+types::ModuleId module;size_t id;ErrorOr<DeprecatedString> to_string() const;
+static JaktInternal::Optional<types::TypeId> none();
+TypeId(types::ModuleId a_module, size_t a_id);
+
+bool equals(types::TypeId const rhs) const;
+static ErrorOr<types::TypeId> from_string(DeprecatedString const type_id_string);
+ErrorOr<DeprecatedString> debug_description() const;
+};struct CheckedEnum {
+  public:
+DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters;JaktInternal::DynamicArray<types::CheckedEnumVariant> variants;JaktInternal::DynamicArray<types::CheckedField> fields;types::ScopeId scope_id;parser::DefinitionLinkage definition_linkage;JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> trait_implementations;parser::RecordType record_type;types::TypeId underlying_type_id;types::TypeId type_id;bool is_boxed;CheckedEnum(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<types::CheckedEnumVariant> a_variants, JaktInternal::DynamicArray<types::CheckedField> a_fields, types::ScopeId a_scope_id, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> a_trait_implementations, parser::RecordType a_record_type, types::TypeId a_underlying_type_id, types::TypeId a_type_id, bool a_is_boxed);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};struct VarId {
+  public:
+types::ModuleId module;size_t id;VarId(types::ModuleId a_module, size_t a_id);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};struct CheckedField {
+  public:
+types::VarId variable_id;JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value;JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_value_expression;CheckedField(types::VarId a_variable_id, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> a_default_value, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_value_expression);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace CheckedCapture_Details {
+struct ByValue {
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+ByValue(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct ByReference {
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+ByReference(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct ByMutableReference {
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+ByMutableReference(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct ByComptimeDependency {
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+ByComptimeDependency(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+struct AllByReference {
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+AllByReference(_MemberT0&& member_0, _MemberT1&& member_1):
+name{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
+{}
+};
+}
+struct CheckedCapture : public Variant<CheckedCapture_Details::ByValue, CheckedCapture_Details::ByReference, CheckedCapture_Details::ByMutableReference, CheckedCapture_Details::ByComptimeDependency, CheckedCapture_Details::AllByReference> {
+using Variant<CheckedCapture_Details::ByValue, CheckedCapture_Details::ByReference, CheckedCapture_Details::ByMutableReference, CheckedCapture_Details::ByComptimeDependency, CheckedCapture_Details::AllByReference>::Variant;
+    using ByValue = CheckedCapture_Details::ByValue;
+    using ByReference = CheckedCapture_Details::ByReference;
+    using ByMutableReference = CheckedCapture_Details::ByMutableReference;
+    using ByComptimeDependency = CheckedCapture_Details::ByComptimeDependency;
+    using AllByReference = CheckedCapture_Details::AllByReference;
+ErrorOr<DeprecatedString> debug_description() const;
+DeprecatedString const& name() const { switch(this->index()) {case 0 /* ByValue */: return this->template get<CheckedCapture::ByValue>().name;
+case 1 /* ByReference */: return this->template get<CheckedCapture::ByReference>().name;
+case 2 /* ByMutableReference */: return this->template get<CheckedCapture::ByMutableReference>().name;
+case 3 /* ByComptimeDependency */: return this->template get<CheckedCapture::ByComptimeDependency>().name;
+case 4 /* AllByReference */: return this->template get<CheckedCapture::AllByReference>().name;
+default: VERIFY_NOT_REACHED();
+}
+}
+utility::Span const& span() const { switch(this->index()) {case 0 /* ByValue */: return this->template get<CheckedCapture::ByValue>().span;
+case 1 /* ByReference */: return this->template get<CheckedCapture::ByReference>().span;
+case 2 /* ByMutableReference */: return this->template get<CheckedCapture::ByMutableReference>().span;
+case 3 /* ByComptimeDependency */: return this->template get<CheckedCapture::ByComptimeDependency>().span;
+case 4 /* AllByReference */: return this->template get<CheckedCapture::AllByReference>().span;
+default: VERIFY_NOT_REACHED();
+}
+}
+};
+struct EnumId {
+  public:
+types::ModuleId module;size_t id;bool equals(types::EnumId const rhs) const;
+EnumId(types::ModuleId a_module, size_t a_id);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace CheckedEnumVariant_Details {
+struct Untyped {
+types::EnumId enum_id;
+DeprecatedString name;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+Untyped(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+enum_id{ forward<_MemberT0>(member_0)},
+name{ forward<_MemberT1>(member_1)},
+span{ forward<_MemberT2>(member_2)}
+{}
+};
+struct Typed {
+types::EnumId enum_id;
+DeprecatedString name;
+types::TypeId type_id;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+Typed(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+enum_id{ forward<_MemberT0>(member_0)},
+name{ forward<_MemberT1>(member_1)},
+type_id{ forward<_MemberT2>(member_2)},
+span{ forward<_MemberT3>(member_3)}
+{}
+};
+struct WithValue {
+types::EnumId enum_id;
+DeprecatedString name;
+NonnullRefPtr<typename types::CheckedExpression> expr;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+WithValue(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+enum_id{ forward<_MemberT0>(member_0)},
+name{ forward<_MemberT1>(member_1)},
+expr{ forward<_MemberT2>(member_2)},
+span{ forward<_MemberT3>(member_3)}
+{}
+};
+struct StructLike {
+types::EnumId enum_id;
+DeprecatedString name;
+JaktInternal::DynamicArray<types::VarId> fields;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+StructLike(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+enum_id{ forward<_MemberT0>(member_0)},
+name{ forward<_MemberT1>(member_1)},
+fields{ forward<_MemberT2>(member_2)},
+span{ forward<_MemberT3>(member_3)}
+{}
+};
+}
+struct CheckedEnumVariant : public Variant<CheckedEnumVariant_Details::Untyped, CheckedEnumVariant_Details::Typed, CheckedEnumVariant_Details::WithValue, CheckedEnumVariant_Details::StructLike> {
+using Variant<CheckedEnumVariant_Details::Untyped, CheckedEnumVariant_Details::Typed, CheckedEnumVariant_Details::WithValue, CheckedEnumVariant_Details::StructLike>::Variant;
+    using Untyped = CheckedEnumVariant_Details::Untyped;
+    using Typed = CheckedEnumVariant_Details::Typed;
+    using WithValue = CheckedEnumVariant_Details::WithValue;
+    using StructLike = CheckedEnumVariant_Details::StructLike;
+ErrorOr<DeprecatedString> debug_description() const;
+types::EnumId enum_id() const;
+DeprecatedString name() const;
+bool equals(types::CheckedEnumVariant const other) const;
+utility::Span span() const;
+};
+struct CheckedParameter {
+  public:
+bool requires_label;NonnullRefPtr<types::CheckedVariable> variable;JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value;ErrorOr<types::CheckedParameter> map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) const;
+CheckedParameter(bool a_requires_label, NonnullRefPtr<types::CheckedVariable> a_variable, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> a_default_value);
+
 ErrorOr<DeprecatedString> debug_description() const;
 };namespace BlockControlFlow_Details {
 struct AlwaysReturns {
@@ -64,240 +300,455 @@ using Variant<BlockControlFlow_Details::AlwaysReturns, BlockControlFlow_Details:
     using PartialAlwaysTransfersControl = BlockControlFlow_Details::PartialAlwaysTransfersControl;
     using PartialNeverReturns = BlockControlFlow_Details::PartialNeverReturns;
 ErrorOr<DeprecatedString> debug_description() const;
-bool always_transfers_control() const;
-types::BlockControlFlow partial() const;
-bool always_returns() const;
 types::BlockControlFlow updated(types::BlockControlFlow const second) const;
-bool may_break() const;
 bool is_reachable() const;
-bool never_returns() const;
-types::BlockControlFlow definitive() const;
-bool may_return() const;
+bool always_returns() const;
+bool always_transfers_control() const;
 types::BlockControlFlow branch_unify_with(types::BlockControlFlow const second) const;
+types::BlockControlFlow definitive() const;
+types::BlockControlFlow partial() const;
+bool may_break() const;
 types::BlockControlFlow unify_with(types::BlockControlFlow const second) const;
+bool may_return() const;
+bool never_returns() const;
 };
-struct TypeId {
-  public:
-types::ModuleId module;size_t id;ErrorOr<DeprecatedString> to_string() const;
-static JaktInternal::Optional<types::TypeId> none();
-bool equals(types::TypeId const rhs) const;
-TypeId(types::ModuleId a_module, size_t a_id);
-
-static ErrorOr<types::TypeId> from_string(DeprecatedString const type_id_string);
-ErrorOr<DeprecatedString> debug_description() const;
-};struct CheckedBlock {
+struct CheckedBlock {
   public:
 JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> statements;types::ScopeId scope_id;types::BlockControlFlow control_flow;JaktInternal::Optional<types::TypeId> yielded_type;bool yielded_none;CheckedBlock(JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> a_statements, types::ScopeId a_scope_id, types::BlockControlFlow a_control_flow, JaktInternal::Optional<types::TypeId> a_yielded_type, bool a_yielded_none);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace CheckedTypeCast_Details {
-struct Fallible{
-types::TypeId value;
-template<typename _MemberT0>
-Fallible(_MemberT0&& member_0):
+};namespace CheckedMatchBody_Details {
+struct Expression{
+NonnullRefPtr<typename types::CheckedExpression> value;
+template<typename _MemberT0>
+Expression(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Infallible{
-types::TypeId value;
+struct Block{
+types::CheckedBlock value;
 template<typename _MemberT0>
-Infallible(_MemberT0&& member_0):
+Block(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
 }
-struct CheckedTypeCast : public Variant<CheckedTypeCast_Details::Fallible, CheckedTypeCast_Details::Infallible> {
-using Variant<CheckedTypeCast_Details::Fallible, CheckedTypeCast_Details::Infallible>::Variant;
-    using Fallible = CheckedTypeCast_Details::Fallible;
-    using Infallible = CheckedTypeCast_Details::Infallible;
+struct CheckedMatchBody : public Variant<CheckedMatchBody_Details::Expression, CheckedMatchBody_Details::Block> {
+using Variant<CheckedMatchBody_Details::Expression, CheckedMatchBody_Details::Block>::Variant;
+    using Expression = CheckedMatchBody_Details::Expression;
+    using Block = CheckedMatchBody_Details::Block;
 ErrorOr<DeprecatedString> debug_description() const;
-types::TypeId type_id() const;
-};
-namespace CheckedNumericConstant_Details {
-struct I8{
-i8 value;
-template<typename _MemberT0>
-I8(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
 };
-struct I16{
-i16 value;
-template<typename _MemberT0>
-I16(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+namespace CheckedMatchCase_Details {
+struct EnumVariant {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults;
+DeprecatedString name;
+JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> args;
+types::TypeId subject_type_id;
+size_t index;
+types::ScopeId scope_id;
+types::CheckedMatchBody body;
+utility::Span marker_span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3, typename _MemberT4, typename _MemberT5, typename _MemberT6, typename _MemberT7>
+EnumVariant(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3, _MemberT4&& member_4, _MemberT5&& member_5, _MemberT6&& member_6, _MemberT7&& member_7):
+defaults{ forward<_MemberT0>(member_0)},
+name{ forward<_MemberT1>(member_1)},
+args{ forward<_MemberT2>(member_2)},
+subject_type_id{ forward<_MemberT3>(member_3)},
+index{ forward<_MemberT4>(member_4)},
+scope_id{ forward<_MemberT5>(member_5)},
+body{ forward<_MemberT6>(member_6)},
+marker_span{ forward<_MemberT7>(member_7)}
 {}
 };
-struct I32{
-i32 value;
-template<typename _MemberT0>
-I32(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct Expression {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults;
+NonnullRefPtr<typename types::CheckedExpression> expression;
+types::CheckedMatchBody body;
+utility::Span marker_span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+Expression(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+defaults{ forward<_MemberT0>(member_0)},
+expression{ forward<_MemberT1>(member_1)},
+body{ forward<_MemberT2>(member_2)},
+marker_span{ forward<_MemberT3>(member_3)}
 {}
 };
-struct I64{
-i64 value;
-template<typename _MemberT0>
-I64(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct CatchAll {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults;
+bool has_arguments;
+types::CheckedMatchBody body;
+utility::Span marker_span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+CatchAll(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+defaults{ forward<_MemberT0>(member_0)},
+has_arguments{ forward<_MemberT1>(member_1)},
+body{ forward<_MemberT2>(member_2)},
+marker_span{ forward<_MemberT3>(member_3)}
 {}
 };
-struct U8{
-u8 value;
-template<typename _MemberT0>
-U8(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+}
+struct CheckedMatchCase : public Variant<CheckedMatchCase_Details::EnumVariant, CheckedMatchCase_Details::Expression, CheckedMatchCase_Details::CatchAll> {
+using Variant<CheckedMatchCase_Details::EnumVariant, CheckedMatchCase_Details::Expression, CheckedMatchCase_Details::CatchAll>::Variant;
+    using EnumVariant = CheckedMatchCase_Details::EnumVariant;
+    using Expression = CheckedMatchCase_Details::Expression;
+    using CatchAll = CheckedMatchCase_Details::CatchAll;
+ErrorOr<DeprecatedString> debug_description() const;
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& defaults() const { switch(this->index()) {case 0 /* EnumVariant */: return this->template get<CheckedMatchCase::EnumVariant>().defaults;
+case 1 /* Expression */: return this->template get<CheckedMatchCase::Expression>().defaults;
+case 2 /* CatchAll */: return this->template get<CheckedMatchCase::CatchAll>().defaults;
+default: VERIFY_NOT_REACHED();
+}
+}
 };
-struct U16{
-u16 value;
+namespace NumericOrStringValue_Details {
+struct StringValue{
+DeprecatedString value;
 template<typename _MemberT0>
-U16(_MemberT0&& member_0):
+StringValue(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct U32{
-u32 value;
+struct SignedNumericValue{
+i64 value;
 template<typename _MemberT0>
-U32(_MemberT0&& member_0):
+SignedNumericValue(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct U64{
+struct UnsignedNumericValue{
 u64 value;
 template<typename _MemberT0>
-U64(_MemberT0&& member_0):
+UnsignedNumericValue(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct USize{
-u64 value;
-template<typename _MemberT0>
-USize(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+}
+struct NumericOrStringValue : public Variant<NumericOrStringValue_Details::StringValue, NumericOrStringValue_Details::SignedNumericValue, NumericOrStringValue_Details::UnsignedNumericValue> {
+using Variant<NumericOrStringValue_Details::StringValue, NumericOrStringValue_Details::SignedNumericValue, NumericOrStringValue_Details::UnsignedNumericValue>::Variant;
+    using StringValue = NumericOrStringValue_Details::StringValue;
+    using SignedNumericValue = NumericOrStringValue_Details::SignedNumericValue;
+    using UnsignedNumericValue = NumericOrStringValue_Details::UnsignedNumericValue;
+ErrorOr<DeprecatedString> debug_description() const;
 };
-struct F32{
-f32 value;
-template<typename _MemberT0>
-F32(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+namespace BuiltinType_Details {
+struct Void {
 };
-struct F64{
-f64 value;
-template<typename _MemberT0>
-F64(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+struct Bool {
 };
-}
-struct CheckedNumericConstant : public Variant<CheckedNumericConstant_Details::I8, CheckedNumericConstant_Details::I16, CheckedNumericConstant_Details::I32, CheckedNumericConstant_Details::I64, CheckedNumericConstant_Details::U8, CheckedNumericConstant_Details::U16, CheckedNumericConstant_Details::U32, CheckedNumericConstant_Details::U64, CheckedNumericConstant_Details::USize, CheckedNumericConstant_Details::F32, CheckedNumericConstant_Details::F64> {
-using Variant<CheckedNumericConstant_Details::I8, CheckedNumericConstant_Details::I16, CheckedNumericConstant_Details::I32, CheckedNumericConstant_Details::I64, CheckedNumericConstant_Details::U8, CheckedNumericConstant_Details::U16, CheckedNumericConstant_Details::U32, CheckedNumericConstant_Details::U64, CheckedNumericConstant_Details::USize, CheckedNumericConstant_Details::F32, CheckedNumericConstant_Details::F64>::Variant;
-    using I8 = CheckedNumericConstant_Details::I8;
-    using I16 = CheckedNumericConstant_Details::I16;
-    using I32 = CheckedNumericConstant_Details::I32;
-    using I64 = CheckedNumericConstant_Details::I64;
-    using U8 = CheckedNumericConstant_Details::U8;
-    using U16 = CheckedNumericConstant_Details::U16;
-    using U32 = CheckedNumericConstant_Details::U32;
-    using U64 = CheckedNumericConstant_Details::U64;
-    using USize = CheckedNumericConstant_Details::USize;
-    using F32 = CheckedNumericConstant_Details::F32;
-    using F64 = CheckedNumericConstant_Details::F64;
-ErrorOr<DeprecatedString> debug_description() const;
-JaktInternal::Optional<types::NumberConstant> number_constant() const;
+struct U8 {
 };
-namespace StringLiteral_Details {
-struct Static{
-DeprecatedString value;
-template<typename _MemberT0>
-Static(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
+struct U16 {
+};
+struct U32 {
+};
+struct U64 {
+};
+struct I8 {
+};
+struct I16 {
+};
+struct I32 {
+};
+struct I64 {
+};
+struct F32 {
+};
+struct F64 {
+};
+struct Usize {
+};
+struct JaktString {
+};
+struct CChar {
+};
+struct CInt {
+};
+struct Unknown {
+};
+struct Never {
 };
 }
-struct StringLiteral : public Variant<StringLiteral_Details::Static> {
-using Variant<StringLiteral_Details::Static>::Variant;
-    using Static = StringLiteral_Details::Static;
+struct BuiltinType : public Variant<BuiltinType_Details::Void, BuiltinType_Details::Bool, BuiltinType_Details::U8, BuiltinType_Details::U16, BuiltinType_Details::U32, BuiltinType_Details::U64, BuiltinType_Details::I8, BuiltinType_Details::I16, BuiltinType_Details::I32, BuiltinType_Details::I64, BuiltinType_Details::F32, BuiltinType_Details::F64, BuiltinType_Details::Usize, BuiltinType_Details::JaktString, BuiltinType_Details::CChar, BuiltinType_Details::CInt, BuiltinType_Details::Unknown, BuiltinType_Details::Never> {
+using Variant<BuiltinType_Details::Void, BuiltinType_Details::Bool, BuiltinType_Details::U8, BuiltinType_Details::U16, BuiltinType_Details::U32, BuiltinType_Details::U64, BuiltinType_Details::I8, BuiltinType_Details::I16, BuiltinType_Details::I32, BuiltinType_Details::I64, BuiltinType_Details::F32, BuiltinType_Details::F64, BuiltinType_Details::Usize, BuiltinType_Details::JaktString, BuiltinType_Details::CChar, BuiltinType_Details::CInt, BuiltinType_Details::Unknown, BuiltinType_Details::Never>::Variant;
+    using Void = BuiltinType_Details::Void;
+    using Bool = BuiltinType_Details::Bool;
+    using U8 = BuiltinType_Details::U8;
+    using U16 = BuiltinType_Details::U16;
+    using U32 = BuiltinType_Details::U32;
+    using U64 = BuiltinType_Details::U64;
+    using I8 = BuiltinType_Details::I8;
+    using I16 = BuiltinType_Details::I16;
+    using I32 = BuiltinType_Details::I32;
+    using I64 = BuiltinType_Details::I64;
+    using F32 = BuiltinType_Details::F32;
+    using F64 = BuiltinType_Details::F64;
+    using Usize = BuiltinType_Details::Usize;
+    using JaktString = BuiltinType_Details::JaktString;
+    using CChar = BuiltinType_Details::CChar;
+    using CInt = BuiltinType_Details::CInt;
+    using Unknown = BuiltinType_Details::Unknown;
+    using Never = BuiltinType_Details::Never;
 ErrorOr<DeprecatedString> debug_description() const;
-DeprecatedString to_string() const;
+size_t id() const;
 };
-struct CheckedStringLiteral {
+class CheckedVariable : public RefCounted<CheckedVariable>, public Weakable<CheckedVariable> {
   public:
-types::StringLiteral value;types::TypeId type_id;bool may_throw;DeprecatedString to_string() const;
-CheckedStringLiteral(types::StringLiteral a_value, types::TypeId a_type_id, bool a_may_throw);
+virtual ~CheckedVariable() = default;
+DeprecatedString name;types::TypeId type_id;bool is_mutable;utility::Span definition_span;JaktInternal::Optional<utility::Span> type_span;types::CheckedVisibility visibility;JaktInternal::Optional<types::ScopeId> owner_scope;ErrorOr<NonnullRefPtr<types::CheckedVariable>> map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) const;
+protected:
+explicit CheckedVariable(DeprecatedString a_name, types::TypeId a_type_id, bool a_is_mutable, utility::Span a_definition_span, JaktInternal::Optional<utility::Span> a_type_span, types::CheckedVisibility a_visibility, JaktInternal::Optional<types::ScopeId> a_owner_scope);
+public:
+static ErrorOr<NonnullRefPtr<CheckedVariable>> __jakt_create(DeprecatedString name, types::TypeId type_id, bool is_mutable, utility::Span definition_span, JaktInternal::Optional<utility::Span> type_span, types::CheckedVisibility visibility, JaktInternal::Optional<types::ScopeId> owner_scope);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};struct EnumId {
+};struct TraitId {
   public:
-types::ModuleId module;size_t id;bool equals(types::EnumId const rhs) const;
-EnumId(types::ModuleId a_module, size_t a_id);
+types::ModuleId module;size_t id;bool equals(types::TraitId const other) const;
+TraitId(types::ModuleId a_module, size_t a_id);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace CheckedEnumVariant_Details {
-struct Untyped {
-types::EnumId enum_id;
-DeprecatedString name;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-Untyped(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
-enum_id{ forward<_MemberT0>(member_0)},
-name{ forward<_MemberT1>(member_1)},
-span{ forward<_MemberT2>(member_2)}
-{}
-};
-struct Typed {
-types::EnumId enum_id;
-DeprecatedString name;
-types::TypeId type_id;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-Typed(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-enum_id{ forward<_MemberT0>(member_0)},
-name{ forward<_MemberT1>(member_1)},
-type_id{ forward<_MemberT2>(member_2)},
-span{ forward<_MemberT3>(member_3)}
+};struct FunctionId {
+  public:
+types::ModuleId module;size_t id;FunctionId(types::ModuleId a_module, size_t a_id);
+
+bool equals(types::FunctionId const rhs) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};struct CheckedCall {
+  public:
+JaktInternal::DynamicArray<types::ResolvedNamespace> namespace_;DeprecatedString name;JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> args;JaktInternal::DynamicArray<types::TypeId> type_args;JaktInternal::Optional<types::FunctionId> function_id;types::TypeId return_type;bool callee_throws;JaktInternal::Optional<DeprecatedString> external_name;CheckedCall(JaktInternal::DynamicArray<types::ResolvedNamespace> a_namespace_, DeprecatedString a_name, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> a_args, JaktInternal::DynamicArray<types::TypeId> a_type_args, JaktInternal::Optional<types::FunctionId> a_function_id, types::TypeId a_return_type, bool a_callee_throws, JaktInternal::Optional<DeprecatedString> a_external_name);
+
+DeprecatedString name_for_codegen() const;
+ErrorOr<DeprecatedString> debug_description() const;
+};struct Value {
+  public:
+NonnullRefPtr<typename types::ValueImpl> impl;utility::Span span;ErrorOr<types::Value> copy() const;
+DeprecatedString type_name() const;
+Value(NonnullRefPtr<typename types::ValueImpl> a_impl, utility::Span a_span);
+
+ErrorOr<types::Value> cast(types::Value const expected, utility::Span const span) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};struct CheckedGenericParameter {
+  public:
+types::TypeId type_id;JaktInternal::DynamicArray<types::TraitId> constraints;utility::Span span;static ErrorOr<types::CheckedGenericParameter> make(types::TypeId const type_id, utility::Span const span);
+CheckedGenericParameter(types::TypeId a_type_id, JaktInternal::DynamicArray<types::TraitId> a_constraints, utility::Span a_span);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};class CheckedProgram : public RefCounted<CheckedProgram>, public Weakable<CheckedProgram> {
+  public:
+virtual ~CheckedProgram() = default;
+NonnullRefPtr<compiler::Compiler> compiler;JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> modules;JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> loaded_modules;ErrorOr<types::TypeId> substitute_typevars_in_type(types::TypeId const type_id, types::GenericInferences const generic_inferences, types::ModuleId const module_id);
+ErrorOr<NonnullRefPtr<types::Scope>> get_scope(types::ScopeId const id) const;
+ErrorOr<types::StructId> find_struct_in_prelude(DeprecatedString const name) const;
+bool is_floating(types::TypeId const type_id) const;
+ErrorOr<JaktInternal::Optional<types::StructId>> find_struct_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+ErrorOr<void> set_loaded_module(DeprecatedString const module_name, types::LoadedModule const loaded_module);
+bool is_integer(types::TypeId const type_id) const;
+ErrorOr<types::ScopeId> create_scope(JaktInternal::Optional<types::ScopeId> const parent_scope_id, bool const can_throw, DeprecatedString const debug_name, types::ModuleId const module_id, bool const for_block);
+NonnullRefPtr<types::Module> get_module(types::ModuleId const id) const;
+ErrorOr<DeprecatedString> type_name(types::TypeId const type_id, bool const debug_mode) const;
+ErrorOr<JaktInternal::Optional<bool>> for_each_scope_accessible_unqualified_from_scope_impl(types::ScopeId const scope_id, Function<ErrorOr<typename utility::IterationDecision<bool>>(types::ScopeId, JaktInternal::Optional<DeprecatedString>, bool)> const& callback) const;
+ErrorOr<bool> is_scope_directly_accessible_from(types::ScopeId const check_scope_id, types::ScopeId const scope_id) const;
+bool is_string(types::TypeId const type_id) const;
+NonnullRefPtr<types::CheckedTrait> get_trait(types::TraitId const id) const;
+types::ScopeId prelude_scope_id() const;
+NonnullRefPtr<types::CheckedVariable> get_variable(types::VarId const id) const;
+protected:
+explicit CheckedProgram(NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> a_modules, JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> a_loaded_modules);
+public:
+static ErrorOr<NonnullRefPtr<CheckedProgram>> __jakt_create(NonnullRefPtr<compiler::Compiler> compiler, JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> modules, JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> loaded_modules);
+
+NonnullRefPtr<types::CheckedFunction> get_function(types::FunctionId const id) const;
+ErrorOr<JaktInternal::Optional<types::Value>> find_comptime_binding_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+ErrorOr<types::TypeId> substitute_typevars_in_type_helper(types::TypeId const type_id, types::GenericInferences const generic_inferences, types::ModuleId const module_id);
+i64 get_bits(types::TypeId const type_id) const;
+NonnullRefPtr<typename types::Type> get_type(types::TypeId const id) const;
+ErrorOr<types::TypeId> find_or_add_type_id(NonnullRefPtr<typename types::Type> const type, types::ModuleId const module_id);
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>>> find_namespace_in_scope(types::ScopeId const scope_id, DeprecatedString const name, bool const treat_aliases_as_imports) const;
+ErrorOr<JaktInternal::Optional<types::TraitId>> find_trait_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+types::CheckedEnum get_enum(types::EnumId const id) const;
+ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>>> find_functions_with_name_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
+ErrorOr<JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>>> find_var_in_scope(types::ScopeId const scope_id, DeprecatedString const var) const;
+ErrorOr<JaktInternal::Optional<types::FunctionId>> find_function_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
+types::CheckedStruct get_struct(types::StructId const id) const;
+ErrorOr<JaktInternal::Optional<types::StructId>> check_and_extract_weak_ptr(types::StructId const struct_id, JaktInternal::DynamicArray<types::TypeId> const args) const;
+ErrorOr<JaktInternal::Optional<types::EnumId>> find_enum_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
+JaktInternal::Optional<types::LoadedModule> get_loaded_module(DeprecatedString const module_name) const;
+ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> find_scoped_functions_with_name_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
+bool is_signed(types::TypeId const type_id) const;
+bool is_numeric(types::TypeId const type_id) const;
+template <typename T>
+ErrorOr<JaktInternal::Optional<T>> for_each_scope_accessible_unqualified_from_scope(types::ScopeId const scope_id, Function<ErrorOr<typename utility::IterationDecision<T>>(types::ScopeId, JaktInternal::Optional<DeprecatedString>, bool)> const& callback) const;
+ErrorOr<types::StructOrEnumId> find_reflected_primitive(DeprecatedString const primitive) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};struct StructId {
+  public:
+types::ModuleId module;size_t id;StructId(types::ModuleId a_module, size_t a_id);
+
+bool equals(types::StructId const rhs) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};class CheckedFunction : public RefCounted<CheckedFunction>, public Weakable<CheckedFunction> {
+  public:
+virtual ~CheckedFunction() = default;
+DeprecatedString name;utility::Span name_span;types::CheckedVisibility visibility;types::TypeId return_type_id;JaktInternal::Optional<utility::Span> return_type_span;JaktInternal::DynamicArray<types::CheckedParameter> params;NonnullRefPtr<types::FunctionGenerics> generics;types::CheckedBlock block;bool can_throw;parser::FunctionType type;parser::FunctionLinkage linkage;types::ScopeId function_scope_id;JaktInternal::Optional<types::StructId> struct_id;bool is_instantiated;JaktInternal::Optional<parser::ParsedFunction> parsed_function;bool is_comptime;bool is_virtual;bool is_override;JaktInternal::Optional<size_t> specialization_index;JaktInternal::Optional<types::ScopeId> owner_scope;JaktInternal::Optional<DeprecatedString> external_name;JaktInternal::Optional<DeprecatedString> deprecated_message;JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> stores_arguments;ErrorOr<void> map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map);
+bool is_static() const;
+bool is_mutating() const;
+protected:
+explicit CheckedFunction(DeprecatedString a_name, utility::Span a_name_span, types::CheckedVisibility a_visibility, types::TypeId a_return_type_id, JaktInternal::Optional<utility::Span> a_return_type_span, JaktInternal::DynamicArray<types::CheckedParameter> a_params, NonnullRefPtr<types::FunctionGenerics> a_generics, types::CheckedBlock a_block, bool a_can_throw, parser::FunctionType a_type, parser::FunctionLinkage a_linkage, types::ScopeId a_function_scope_id, JaktInternal::Optional<types::StructId> a_struct_id, bool a_is_instantiated, JaktInternal::Optional<parser::ParsedFunction> a_parsed_function, bool a_is_comptime, bool a_is_virtual, bool a_is_override, JaktInternal::Optional<size_t> a_specialization_index, JaktInternal::Optional<types::ScopeId> a_owner_scope, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Optional<DeprecatedString> a_deprecated_message, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> a_stores_arguments);
+public:
+static ErrorOr<NonnullRefPtr<CheckedFunction>> __jakt_create(DeprecatedString name, utility::Span name_span, types::CheckedVisibility visibility, types::TypeId return_type_id, JaktInternal::Optional<utility::Span> return_type_span, JaktInternal::DynamicArray<types::CheckedParameter> params, NonnullRefPtr<types::FunctionGenerics> generics, types::CheckedBlock block, bool can_throw, parser::FunctionType type, parser::FunctionLinkage linkage, types::ScopeId function_scope_id, JaktInternal::Optional<types::StructId> struct_id, bool is_instantiated, JaktInternal::Optional<parser::ParsedFunction> parsed_function, bool is_comptime, bool is_virtual, bool is_override, JaktInternal::Optional<size_t> specialization_index, JaktInternal::Optional<types::ScopeId> owner_scope, JaktInternal::Optional<DeprecatedString> external_name, JaktInternal::Optional<DeprecatedString> deprecated_message, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> stores_arguments);
+
+parser::ParsedFunction to_parsed_function() const;
+bool is_specialized_for_types(JaktInternal::DynamicArray<types::TypeId> const types) const;
+ErrorOr<NonnullRefPtr<types::CheckedFunction>> copy() const;
+ErrorOr<bool> signature_matches(NonnullRefPtr<types::CheckedFunction> const other) const;
+DeprecatedString name_for_codegen() const;
+ErrorOr<void> add_param(types::CheckedParameter const checked_param);
+ErrorOr<void> set_params(JaktInternal::DynamicArray<types::CheckedParameter> const checked_params);
+ErrorOr<DeprecatedString> debug_description() const;
+};struct FieldRecord {
+  public:
+types::StructId struct_id;types::VarId field_id;FieldRecord(types::StructId a_struct_id, types::VarId a_field_id);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace CheckedNumericConstant_Details {
+struct I8{
+i8 value;
+template<typename _MemberT0>
+I8(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct WithValue {
-types::EnumId enum_id;
-DeprecatedString name;
-NonnullRefPtr<typename types::CheckedExpression> expr;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-WithValue(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-enum_id{ forward<_MemberT0>(member_0)},
-name{ forward<_MemberT1>(member_1)},
-expr{ forward<_MemberT2>(member_2)},
-span{ forward<_MemberT3>(member_3)}
+struct I16{
+i16 value;
+template<typename _MemberT0>
+I16(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct StructLike {
-types::EnumId enum_id;
-DeprecatedString name;
-JaktInternal::DynamicArray<types::VarId> fields;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-StructLike(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-enum_id{ forward<_MemberT0>(member_0)},
-name{ forward<_MemberT1>(member_1)},
-fields{ forward<_MemberT2>(member_2)},
-span{ forward<_MemberT3>(member_3)}
+struct I32{
+i32 value;
+template<typename _MemberT0>
+I32(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct I64{
+i64 value;
+template<typename _MemberT0>
+I64(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct U8{
+u8 value;
+template<typename _MemberT0>
+U8(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct U16{
+u16 value;
+template<typename _MemberT0>
+U16(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct U32{
+u32 value;
+template<typename _MemberT0>
+U32(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct U64{
+u64 value;
+template<typename _MemberT0>
+U64(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct USize{
+u64 value;
+template<typename _MemberT0>
+USize(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct F32{
+f32 value;
+template<typename _MemberT0>
+F32(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct F64{
+f64 value;
+template<typename _MemberT0>
+F64(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
 {}
 };
 }
-struct CheckedEnumVariant : public Variant<CheckedEnumVariant_Details::Untyped, CheckedEnumVariant_Details::Typed, CheckedEnumVariant_Details::WithValue, CheckedEnumVariant_Details::StructLike> {
-using Variant<CheckedEnumVariant_Details::Untyped, CheckedEnumVariant_Details::Typed, CheckedEnumVariant_Details::WithValue, CheckedEnumVariant_Details::StructLike>::Variant;
-    using Untyped = CheckedEnumVariant_Details::Untyped;
-    using Typed = CheckedEnumVariant_Details::Typed;
-    using WithValue = CheckedEnumVariant_Details::WithValue;
-    using StructLike = CheckedEnumVariant_Details::StructLike;
+struct CheckedNumericConstant : public Variant<CheckedNumericConstant_Details::I8, CheckedNumericConstant_Details::I16, CheckedNumericConstant_Details::I32, CheckedNumericConstant_Details::I64, CheckedNumericConstant_Details::U8, CheckedNumericConstant_Details::U16, CheckedNumericConstant_Details::U32, CheckedNumericConstant_Details::U64, CheckedNumericConstant_Details::USize, CheckedNumericConstant_Details::F32, CheckedNumericConstant_Details::F64> {
+using Variant<CheckedNumericConstant_Details::I8, CheckedNumericConstant_Details::I16, CheckedNumericConstant_Details::I32, CheckedNumericConstant_Details::I64, CheckedNumericConstant_Details::U8, CheckedNumericConstant_Details::U16, CheckedNumericConstant_Details::U32, CheckedNumericConstant_Details::U64, CheckedNumericConstant_Details::USize, CheckedNumericConstant_Details::F32, CheckedNumericConstant_Details::F64>::Variant;
+    using I8 = CheckedNumericConstant_Details::I8;
+    using I16 = CheckedNumericConstant_Details::I16;
+    using I32 = CheckedNumericConstant_Details::I32;
+    using I64 = CheckedNumericConstant_Details::I64;
+    using U8 = CheckedNumericConstant_Details::U8;
+    using U16 = CheckedNumericConstant_Details::U16;
+    using U32 = CheckedNumericConstant_Details::U32;
+    using U64 = CheckedNumericConstant_Details::U64;
+    using USize = CheckedNumericConstant_Details::USize;
+    using F32 = CheckedNumericConstant_Details::F32;
+    using F64 = CheckedNumericConstant_Details::F64;
 ErrorOr<DeprecatedString> debug_description() const;
-types::EnumId enum_id() const;
-DeprecatedString name() const;
-bool equals(types::CheckedEnumVariant const other) const;
-utility::Span span() const;
+JaktInternal::Optional<types::NumberConstant> number_constant() const;
+};
+namespace StringLiteral_Details {
+struct Static{
+DeprecatedString value;
+template<typename _MemberT0>
+Static(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+}
+struct StringLiteral : public Variant<StringLiteral_Details::Static> {
+using Variant<StringLiteral_Details::Static>::Variant;
+    using Static = StringLiteral_Details::Static;
+ErrorOr<DeprecatedString> debug_description() const;
+DeprecatedString to_string() const;
+};
+struct CheckedStringLiteral {
+  public:
+types::StringLiteral value;types::TypeId type_id;bool may_throw;DeprecatedString to_string() const;
+CheckedStringLiteral(types::StringLiteral a_value, types::TypeId a_type_id, bool a_may_throw);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace CheckedTypeCast_Details {
+struct Fallible{
+types::TypeId value;
+template<typename _MemberT0>
+Fallible(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct Infallible{
+types::TypeId value;
+template<typename _MemberT0>
+Infallible(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+}
+struct CheckedTypeCast : public Variant<CheckedTypeCast_Details::Fallible, CheckedTypeCast_Details::Infallible> {
+using Variant<CheckedTypeCast_Details::Fallible, CheckedTypeCast_Details::Infallible>::Variant;
+    using Fallible = CheckedTypeCast_Details::Fallible;
+    using Infallible = CheckedTypeCast_Details::Infallible;
+ErrorOr<DeprecatedString> debug_description() const;
+types::TypeId type_id() const;
 };
 namespace CheckedUnaryOperator_Details {
 struct PreIncrement {
@@ -379,221 +830,7 @@ struct CheckedEnumVariantBinding {
 JaktInternal::Optional<DeprecatedString> name;DeprecatedString binding;types::TypeId type_id;utility::Span span;CheckedEnumVariantBinding(JaktInternal::Optional<DeprecatedString> a_name, DeprecatedString a_binding, types::TypeId a_type_id, utility::Span a_span);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};struct FunctionId {
-  public:
-types::ModuleId module;size_t id;bool equals(types::FunctionId const rhs) const;
-FunctionId(types::ModuleId a_module, size_t a_id);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct CheckedCall {
-  public:
-JaktInternal::DynamicArray<types::ResolvedNamespace> namespace_;DeprecatedString name;JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> args;JaktInternal::DynamicArray<types::TypeId> type_args;JaktInternal::Optional<types::FunctionId> function_id;types::TypeId return_type;bool callee_throws;JaktInternal::Optional<DeprecatedString> external_name;CheckedCall(JaktInternal::DynamicArray<types::ResolvedNamespace> a_namespace_, DeprecatedString a_name, JaktInternal::DynamicArray<JaktInternal::Tuple<DeprecatedString,NonnullRefPtr<typename types::CheckedExpression>>> a_args, JaktInternal::DynamicArray<types::TypeId> a_type_args, JaktInternal::Optional<types::FunctionId> a_function_id, types::TypeId a_return_type, bool a_callee_throws, JaktInternal::Optional<DeprecatedString> a_external_name);
-
-DeprecatedString name_for_codegen() const;
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace CheckedVisibility_Details {
-struct Public {
-};
-struct Private {
-};
-struct Restricted {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::MaybeResolvedScope>> scopes;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Restricted(_MemberT0&& member_0, _MemberT1&& member_1):
-scopes{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-}
-struct CheckedVisibility : public Variant<CheckedVisibility_Details::Public, CheckedVisibility_Details::Private, CheckedVisibility_Details::Restricted> {
-using Variant<CheckedVisibility_Details::Public, CheckedVisibility_Details::Private, CheckedVisibility_Details::Restricted>::Variant;
-    using Public = CheckedVisibility_Details::Public;
-    using Private = CheckedVisibility_Details::Private;
-    using Restricted = CheckedVisibility_Details::Restricted;
-ErrorOr<DeprecatedString> debug_description() const;
-};
-class CheckedVariable : public RefCounted<CheckedVariable>, public Weakable<CheckedVariable> {
-  public:
-virtual ~CheckedVariable() = default;
-DeprecatedString name;types::TypeId type_id;bool is_mutable;utility::Span definition_span;JaktInternal::Optional<utility::Span> type_span;types::CheckedVisibility visibility;JaktInternal::Optional<types::ScopeId> owner_scope;ErrorOr<NonnullRefPtr<types::CheckedVariable>> map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) const;
-protected:
-explicit CheckedVariable(DeprecatedString a_name, types::TypeId a_type_id, bool a_is_mutable, utility::Span a_definition_span, JaktInternal::Optional<utility::Span> a_type_span, types::CheckedVisibility a_visibility, JaktInternal::Optional<types::ScopeId> a_owner_scope);
-public:
-static ErrorOr<NonnullRefPtr<CheckedVariable>> __jakt_create(DeprecatedString name, types::TypeId type_id, bool is_mutable, utility::Span definition_span, JaktInternal::Optional<utility::Span> type_span, types::CheckedVisibility visibility, JaktInternal::Optional<types::ScopeId> owner_scope);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct VarId {
-  public:
-types::ModuleId module;size_t id;VarId(types::ModuleId a_module, size_t a_id);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace CheckedStatement_Details {
-struct Expression {
-NonnullRefPtr<typename types::CheckedExpression> expr;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Expression(_MemberT0&& member_0, _MemberT1&& member_1):
-expr{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Defer {
-NonnullRefPtr<typename types::CheckedStatement> statement;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Defer(_MemberT0&& member_0, _MemberT1&& member_1):
-statement{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct DestructuringAssignment {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> vars;
-NonnullRefPtr<typename types::CheckedStatement> var_decl;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-DestructuringAssignment(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
-vars{ forward<_MemberT0>(member_0)},
-var_decl{ forward<_MemberT1>(member_1)},
-span{ forward<_MemberT2>(member_2)}
-{}
-};
-struct VarDecl {
-types::VarId var_id;
-NonnullRefPtr<typename types::CheckedExpression> init;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-VarDecl(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
-var_id{ forward<_MemberT0>(member_0)},
-init{ forward<_MemberT1>(member_1)},
-span{ forward<_MemberT2>(member_2)}
-{}
-};
-struct If {
-NonnullRefPtr<typename types::CheckedExpression> condition;
-types::CheckedBlock then_block;
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> else_statement;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-If(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-condition{ forward<_MemberT0>(member_0)},
-then_block{ forward<_MemberT1>(member_1)},
-else_statement{ forward<_MemberT2>(member_2)},
-span{ forward<_MemberT3>(member_3)}
-{}
-};
-struct Block {
-types::CheckedBlock block;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Block(_MemberT0&& member_0, _MemberT1&& member_1):
-block{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Loop {
-types::CheckedBlock block;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Loop(_MemberT0&& member_0, _MemberT1&& member_1):
-block{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct While {
-NonnullRefPtr<typename types::CheckedExpression> condition;
-types::CheckedBlock block;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
-While(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
-condition{ forward<_MemberT0>(member_0)},
-block{ forward<_MemberT1>(member_1)},
-span{ forward<_MemberT2>(member_2)}
-{}
-};
-struct Return {
-JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> val;
-JaktInternal::Optional<utility::Span> span;
-template<typename _MemberT0, typename _MemberT1>
-Return(_MemberT0&& member_0, _MemberT1&& member_1):
-val{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Break{
-utility::Span value;
-template<typename _MemberT0>
-Break(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-struct Continue{
-utility::Span value;
-template<typename _MemberT0>
-Continue(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-struct Throw {
-NonnullRefPtr<typename types::CheckedExpression> expr;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Throw(_MemberT0&& member_0, _MemberT1&& member_1):
-expr{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Yield {
-NonnullRefPtr<typename types::CheckedExpression> expr;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-Yield(_MemberT0&& member_0, _MemberT1&& member_1):
-expr{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct InlineCpp {
-JaktInternal::DynamicArray<DeprecatedString> lines;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-InlineCpp(_MemberT0&& member_0, _MemberT1&& member_1):
-lines{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct Garbage{
-utility::Span value;
-template<typename _MemberT0>
-Garbage(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-}
-struct CheckedStatement : public Variant<CheckedStatement_Details::Expression, CheckedStatement_Details::Defer, CheckedStatement_Details::DestructuringAssignment, CheckedStatement_Details::VarDecl, CheckedStatement_Details::If, CheckedStatement_Details::Block, CheckedStatement_Details::Loop, CheckedStatement_Details::While, CheckedStatement_Details::Return, CheckedStatement_Details::Break, CheckedStatement_Details::Continue, CheckedStatement_Details::Throw, CheckedStatement_Details::Yield, CheckedStatement_Details::InlineCpp, CheckedStatement_Details::Garbage>, public RefCounted<CheckedStatement> {
-using Variant<CheckedStatement_Details::Expression, CheckedStatement_Details::Defer, CheckedStatement_Details::DestructuringAssignment, CheckedStatement_Details::VarDecl, CheckedStatement_Details::If, CheckedStatement_Details::Block, CheckedStatement_Details::Loop, CheckedStatement_Details::While, CheckedStatement_Details::Return, CheckedStatement_Details::Break, CheckedStatement_Details::Continue, CheckedStatement_Details::Throw, CheckedStatement_Details::Yield, CheckedStatement_Details::InlineCpp, CheckedStatement_Details::Garbage>::Variant;
-    using Expression = CheckedStatement_Details::Expression;
-    using Defer = CheckedStatement_Details::Defer;
-    using DestructuringAssignment = CheckedStatement_Details::DestructuringAssignment;
-    using VarDecl = CheckedStatement_Details::VarDecl;
-    using If = CheckedStatement_Details::If;
-    using Block = CheckedStatement_Details::Block;
-    using Loop = CheckedStatement_Details::Loop;
-    using While = CheckedStatement_Details::While;
-    using Return = CheckedStatement_Details::Return;
-    using Break = CheckedStatement_Details::Break;
-    using Continue = CheckedStatement_Details::Continue;
-    using Throw = CheckedStatement_Details::Throw;
-    using Yield = CheckedStatement_Details::Yield;
-    using InlineCpp = CheckedStatement_Details::InlineCpp;
-    using Garbage = CheckedStatement_Details::Garbage;
-template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
-return adopt_nonnull_ref_or_enomem(new (nothrow) CheckedStatement(V(forward<Args>(args)...)));
-}
-ErrorOr<DeprecatedString> debug_description() const;
-static JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> none();
-JaktInternal::Optional<utility::Span> span() const;
-};
-namespace CheckedExpression_Details {
+};namespace CheckedExpression_Details {
 struct Boolean {
 bool val;
 utility::Span span;
@@ -1085,25 +1322,51 @@ template<typename V, typename... Args> static auto __jakt_create(Args&&... args)
 return adopt_nonnull_ref_or_enomem(new (nothrow) CheckedExpression(V(forward<Args>(args)...)));
 }
 ErrorOr<DeprecatedString> debug_description() const;
-utility::Span span() const;
 bool can_throw() const;
-bool is_mutable(NonnullRefPtr<types::CheckedProgram> const program) const;
 JaktInternal::Optional<types::NumberConstant> to_number_constant(NonnullRefPtr<types::CheckedProgram> const program) const;
+utility::Span span() const;
 types::TypeId type() const;
 types::BlockControlFlow control_flow() const;
+bool is_mutable(NonnullRefPtr<types::CheckedProgram> const program) const;
 };
-struct LoadedModule {
+struct CheckedNamespace {
   public:
-types::ModuleId module_id;utility::FileId file_id;LoadedModule(types::ModuleId a_module_id, utility::FileId a_file_id);
+DeprecatedString name;types::ScopeId scope;CheckedNamespace(DeprecatedString a_name, types::ScopeId a_scope);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};struct TraitId {
+};namespace StructOrEnumId_Details {
+struct Struct{
+types::StructId value;
+template<typename _MemberT0>
+Struct(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct Enum{
+types::EnumId value;
+template<typename _MemberT0>
+Enum(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+}
+struct StructOrEnumId : public Variant<StructOrEnumId_Details::Struct, StructOrEnumId_Details::Enum> {
+using Variant<StructOrEnumId_Details::Struct, StructOrEnumId_Details::Enum>::Variant;
+    using Struct = StructOrEnumId_Details::Struct;
+    using Enum = StructOrEnumId_Details::Enum;
+ErrorOr<DeprecatedString> debug_description() const;
+};
+class FunctionGenerics : public RefCounted<FunctionGenerics>, public Weakable<FunctionGenerics> {
   public:
-types::ModuleId module;size_t id;bool equals(types::TraitId const other) const;
-TraitId(types::ModuleId a_module, size_t a_id);
+virtual ~FunctionGenerics() = default;
+types::ScopeId base_scope_id;JaktInternal::DynamicArray<types::CheckedParameter> base_params;JaktInternal::DynamicArray<types::FunctionGenericParameter> params;JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> specializations;protected:
+explicit FunctionGenerics(types::ScopeId a_base_scope_id, JaktInternal::DynamicArray<types::CheckedParameter> a_base_params, JaktInternal::DynamicArray<types::FunctionGenericParameter> a_params, JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> a_specializations);
+public:
+static ErrorOr<NonnullRefPtr<FunctionGenerics>> __jakt_create(types::ScopeId base_scope_id, JaktInternal::DynamicArray<types::CheckedParameter> base_params, JaktInternal::DynamicArray<types::FunctionGenericParameter> params, JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> specializations);
 
+bool is_specialized_for_types(JaktInternal::DynamicArray<types::TypeId> const types) const;
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace BuiltinType_Details {
+};namespace Type_Details {
 struct Void {
 };
 struct Bool {
@@ -1140,223 +1403,51 @@ struct Unknown {
 };
 struct Never {
 };
-}
-struct BuiltinType : public Variant<BuiltinType_Details::Void, BuiltinType_Details::Bool, BuiltinType_Details::U8, BuiltinType_Details::U16, BuiltinType_Details::U32, BuiltinType_Details::U64, BuiltinType_Details::I8, BuiltinType_Details::I16, BuiltinType_Details::I32, BuiltinType_Details::I64, BuiltinType_Details::F32, BuiltinType_Details::F64, BuiltinType_Details::Usize, BuiltinType_Details::JaktString, BuiltinType_Details::CChar, BuiltinType_Details::CInt, BuiltinType_Details::Unknown, BuiltinType_Details::Never> {
-using Variant<BuiltinType_Details::Void, BuiltinType_Details::Bool, BuiltinType_Details::U8, BuiltinType_Details::U16, BuiltinType_Details::U32, BuiltinType_Details::U64, BuiltinType_Details::I8, BuiltinType_Details::I16, BuiltinType_Details::I32, BuiltinType_Details::I64, BuiltinType_Details::F32, BuiltinType_Details::F64, BuiltinType_Details::Usize, BuiltinType_Details::JaktString, BuiltinType_Details::CChar, BuiltinType_Details::CInt, BuiltinType_Details::Unknown, BuiltinType_Details::Never>::Variant;
-    using Void = BuiltinType_Details::Void;
-    using Bool = BuiltinType_Details::Bool;
-    using U8 = BuiltinType_Details::U8;
-    using U16 = BuiltinType_Details::U16;
-    using U32 = BuiltinType_Details::U32;
-    using U64 = BuiltinType_Details::U64;
-    using I8 = BuiltinType_Details::I8;
-    using I16 = BuiltinType_Details::I16;
-    using I32 = BuiltinType_Details::I32;
-    using I64 = BuiltinType_Details::I64;
-    using F32 = BuiltinType_Details::F32;
-    using F64 = BuiltinType_Details::F64;
-    using Usize = BuiltinType_Details::Usize;
-    using JaktString = BuiltinType_Details::JaktString;
-    using CChar = BuiltinType_Details::CChar;
-    using CInt = BuiltinType_Details::CInt;
-    using Unknown = BuiltinType_Details::Unknown;
-    using Never = BuiltinType_Details::Never;
-ErrorOr<DeprecatedString> debug_description() const;
-size_t id() const;
-};
-namespace CheckedCapture_Details {
-struct ByValue {
-DeprecatedString name;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-ByValue(_MemberT0&& member_0, _MemberT1&& member_1):
-name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct ByReference {
-DeprecatedString name;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-ByReference(_MemberT0&& member_0, _MemberT1&& member_1):
-name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct ByMutableReference {
-DeprecatedString name;
-utility::Span span;
-template<typename _MemberT0, typename _MemberT1>
-ByMutableReference(_MemberT0&& member_0, _MemberT1&& member_1):
-name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
-{}
-};
-struct ByComptimeDependency {
+struct TypeVariable {
 DeprecatedString name;
-utility::Span span;
+JaktInternal::DynamicArray<types::TypeId> trait_implementations;
 template<typename _MemberT0, typename _MemberT1>
-ByComptimeDependency(_MemberT0&& member_0, _MemberT1&& member_1):
+TypeVariable(_MemberT0&& member_0, _MemberT1&& member_1):
 name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+trait_implementations{ forward<_MemberT1>(member_1)}
 {}
 };
-struct AllByReference {
-DeprecatedString name;
-utility::Span span;
+struct GenericInstance {
+types::StructId id;
+JaktInternal::DynamicArray<types::TypeId> args;
 template<typename _MemberT0, typename _MemberT1>
-AllByReference(_MemberT0&& member_0, _MemberT1&& member_1):
-name{ forward<_MemberT0>(member_0)},
-span{ forward<_MemberT1>(member_1)}
+GenericInstance(_MemberT0&& member_0, _MemberT1&& member_1):
+id{ forward<_MemberT0>(member_0)},
+args{ forward<_MemberT1>(member_1)}
 {}
 };
-}
-struct CheckedCapture : public Variant<CheckedCapture_Details::ByValue, CheckedCapture_Details::ByReference, CheckedCapture_Details::ByMutableReference, CheckedCapture_Details::ByComptimeDependency, CheckedCapture_Details::AllByReference> {
-using Variant<CheckedCapture_Details::ByValue, CheckedCapture_Details::ByReference, CheckedCapture_Details::ByMutableReference, CheckedCapture_Details::ByComptimeDependency, CheckedCapture_Details::AllByReference>::Variant;
-    using ByValue = CheckedCapture_Details::ByValue;
-    using ByReference = CheckedCapture_Details::ByReference;
-    using ByMutableReference = CheckedCapture_Details::ByMutableReference;
-    using ByComptimeDependency = CheckedCapture_Details::ByComptimeDependency;
-    using AllByReference = CheckedCapture_Details::AllByReference;
-ErrorOr<DeprecatedString> debug_description() const;
-DeprecatedString const& name() const { switch(this->index()) {case 0 /* ByValue */: return this->template get<CheckedCapture::ByValue>().name;
-case 1 /* ByReference */: return this->template get<CheckedCapture::ByReference>().name;
-case 2 /* ByMutableReference */: return this->template get<CheckedCapture::ByMutableReference>().name;
-case 3 /* ByComptimeDependency */: return this->template get<CheckedCapture::ByComptimeDependency>().name;
-case 4 /* AllByReference */: return this->template get<CheckedCapture::AllByReference>().name;
-default: VERIFY_NOT_REACHED();
-}
-}
-utility::Span const& span() const { switch(this->index()) {case 0 /* ByValue */: return this->template get<CheckedCapture::ByValue>().span;
-case 1 /* ByReference */: return this->template get<CheckedCapture::ByReference>().span;
-case 2 /* ByMutableReference */: return this->template get<CheckedCapture::ByMutableReference>().span;
-case 3 /* ByComptimeDependency */: return this->template get<CheckedCapture::ByComptimeDependency>().span;
-case 4 /* AllByReference */: return this->template get<CheckedCapture::AllByReference>().span;
-default: VERIFY_NOT_REACHED();
-}
-}
-};
-struct CheckedNamespace {
-  public:
-DeprecatedString name;types::ScopeId scope;CheckedNamespace(DeprecatedString a_name, types::ScopeId a_scope);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};class Scope : public RefCounted<Scope>, public Weakable<Scope> {
-  public:
-virtual ~Scope() = default;
-JaktInternal::Optional<DeprecatedString> namespace_name;JaktInternal::Optional<DeprecatedString> external_name;JaktInternal::Dictionary<DeprecatedString,types::VarId> vars;JaktInternal::Dictionary<DeprecatedString,types::Value> comptime_bindings;JaktInternal::Dictionary<DeprecatedString,types::StructId> structs;JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> functions;JaktInternal::Dictionary<DeprecatedString,types::EnumId> enums;JaktInternal::Dictionary<DeprecatedString,types::TypeId> types;JaktInternal::Dictionary<DeprecatedString,types::TraitId> traits;JaktInternal::Dictionary<DeprecatedString,types::ModuleId> imports;JaktInternal::Dictionary<DeprecatedString,types::ScopeId> aliases;JaktInternal::Optional<types::ScopeId> parent;JaktInternal::Optional<types::ScopeId> alias_scope;JaktInternal::DynamicArray<types::ScopeId> children;bool can_throw;JaktInternal::Optional<DeprecatedString> import_path_if_extern;JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> alias_path;JaktInternal::DynamicArray<parser::IncludeAction> after_extern_include;JaktInternal::DynamicArray<parser::IncludeAction> before_extern_include;DeprecatedString debug_name;JaktInternal::DynamicArray<types::ScopeId> resolution_mixins;bool is_block_scope;protected:
-explicit Scope(JaktInternal::Optional<DeprecatedString> a_namespace_name, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Dictionary<DeprecatedString,types::VarId> a_vars, JaktInternal::Dictionary<DeprecatedString,types::Value> a_comptime_bindings, JaktInternal::Dictionary<DeprecatedString,types::StructId> a_structs, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> a_functions, JaktInternal::Dictionary<DeprecatedString,types::EnumId> a_enums, JaktInternal::Dictionary<DeprecatedString,types::TypeId> a_types, JaktInternal::Dictionary<DeprecatedString,types::TraitId> a_traits, JaktInternal::Dictionary<DeprecatedString,types::ModuleId> a_imports, JaktInternal::Dictionary<DeprecatedString,types::ScopeId> a_aliases, JaktInternal::Optional<types::ScopeId> a_parent, JaktInternal::Optional<types::ScopeId> a_alias_scope, JaktInternal::DynamicArray<types::ScopeId> a_children, bool a_can_throw, JaktInternal::Optional<DeprecatedString> a_import_path_if_extern, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> a_alias_path, JaktInternal::DynamicArray<parser::IncludeAction> a_after_extern_include, JaktInternal::DynamicArray<parser::IncludeAction> a_before_extern_include, DeprecatedString a_debug_name, JaktInternal::DynamicArray<types::ScopeId> a_resolution_mixins, bool a_is_block_scope);
-public:
-static ErrorOr<NonnullRefPtr<Scope>> __jakt_create(JaktInternal::Optional<DeprecatedString> namespace_name, JaktInternal::Optional<DeprecatedString> external_name, JaktInternal::Dictionary<DeprecatedString,types::VarId> vars, JaktInternal::Dictionary<DeprecatedString,types::Value> comptime_bindings, JaktInternal::Dictionary<DeprecatedString,types::StructId> structs, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> functions, JaktInternal::Dictionary<DeprecatedString,types::EnumId> enums, JaktInternal::Dictionary<DeprecatedString,types::TypeId> types, JaktInternal::Dictionary<DeprecatedString,types::TraitId> traits, JaktInternal::Dictionary<DeprecatedString,types::ModuleId> imports, JaktInternal::Dictionary<DeprecatedString,types::ScopeId> aliases, JaktInternal::Optional<types::ScopeId> parent, JaktInternal::Optional<types::ScopeId> alias_scope, JaktInternal::DynamicArray<types::ScopeId> children, bool can_throw, JaktInternal::Optional<DeprecatedString> import_path_if_extern, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> alias_path, JaktInternal::DynamicArray<parser::IncludeAction> after_extern_include, JaktInternal::DynamicArray<parser::IncludeAction> before_extern_include, DeprecatedString debug_name, JaktInternal::DynamicArray<types::ScopeId> resolution_mixins, bool is_block_scope);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};class FunctionGenerics : public RefCounted<FunctionGenerics>, public Weakable<FunctionGenerics> {
-  public:
-virtual ~FunctionGenerics() = default;
-types::ScopeId base_scope_id;JaktInternal::DynamicArray<types::CheckedParameter> base_params;JaktInternal::DynamicArray<types::FunctionGenericParameter> params;JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> specializations;protected:
-explicit FunctionGenerics(types::ScopeId a_base_scope_id, JaktInternal::DynamicArray<types::CheckedParameter> a_base_params, JaktInternal::DynamicArray<types::FunctionGenericParameter> a_params, JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> a_specializations);
-public:
-static ErrorOr<NonnullRefPtr<FunctionGenerics>> __jakt_create(types::ScopeId base_scope_id, JaktInternal::DynamicArray<types::CheckedParameter> base_params, JaktInternal::DynamicArray<types::FunctionGenericParameter> params, JaktInternal::DynamicArray<JaktInternal::DynamicArray<types::TypeId>> specializations);
-
-bool is_specialized_for_types(JaktInternal::DynamicArray<types::TypeId> const types) const;
-ErrorOr<DeprecatedString> debug_description() const;
-};class CheckedProgram : public RefCounted<CheckedProgram>, public Weakable<CheckedProgram> {
-  public:
-virtual ~CheckedProgram() = default;
-NonnullRefPtr<compiler::Compiler> compiler;JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> modules;JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> loaded_modules;bool is_floating(types::TypeId const type_id) const;
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<JaktInternal::DynamicArray<types::FunctionId>,types::ScopeId>>> find_scoped_functions_with_name_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
-bool is_signed(types::TypeId const type_id) const;
-ErrorOr<JaktInternal::Optional<types::StructId>> find_struct_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
-ErrorOr<void> set_loaded_module(DeprecatedString const module_name, types::LoadedModule const loaded_module);
-bool is_integer(types::TypeId const type_id) const;
-ErrorOr<types::ScopeId> create_scope(JaktInternal::Optional<types::ScopeId> const parent_scope_id, bool const can_throw, DeprecatedString const debug_name, types::ModuleId const module_id, bool const for_block);
-ErrorOr<types::TypeId> substitute_typevars_in_type(types::TypeId const type_id, types::GenericInferences const generic_inferences, types::ModuleId const module_id);
-NonnullRefPtr<types::Module> get_module(types::ModuleId const id) const;
-ErrorOr<JaktInternal::Optional<bool>> for_each_scope_accessible_unqualified_from_scope_impl(types::ScopeId const scope_id, Function<ErrorOr<typename utility::IterationDecision<bool>>(types::ScopeId, JaktInternal::Optional<DeprecatedString>, bool)> const& callback) const;
-ErrorOr<bool> is_scope_directly_accessible_from(types::ScopeId const check_scope_id, types::ScopeId const scope_id) const;
-ErrorOr<types::TypeId> substitute_typevars_in_type_helper(types::TypeId const type_id, types::GenericInferences const generic_inferences, types::ModuleId const module_id);
-bool is_string(types::TypeId const type_id) const;
-types::ScopeId prelude_scope_id() const;
-protected:
-explicit CheckedProgram(NonnullRefPtr<compiler::Compiler> a_compiler, JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> a_modules, JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> a_loaded_modules);
-public:
-static ErrorOr<NonnullRefPtr<CheckedProgram>> __jakt_create(NonnullRefPtr<compiler::Compiler> compiler, JaktInternal::DynamicArray<NonnullRefPtr<types::Module>> modules, JaktInternal::Dictionary<DeprecatedString,types::LoadedModule> loaded_modules);
-
-NonnullRefPtr<types::CheckedFunction> get_function(types::FunctionId const id) const;
-ErrorOr<JaktInternal::Optional<types::Value>> find_comptime_binding_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
-i64 get_bits(types::TypeId const type_id) const;
-NonnullRefPtr<typename types::Type> get_type(types::TypeId const id) const;
-ErrorOr<types::TypeId> find_or_add_type_id(NonnullRefPtr<typename types::Type> const type, types::ModuleId const module_id);
-ErrorOr<types::StructId> find_struct_in_prelude(DeprecatedString const name) const;
-ErrorOr<JaktInternal::Optional<JaktInternal::Tuple<types::ScopeId,bool>>> find_namespace_in_scope(types::ScopeId const scope_id, DeprecatedString const name, bool const treat_aliases_as_imports) const;
-types::CheckedEnum get_enum(types::EnumId const id) const;
-template <typename T>
-ErrorOr<JaktInternal::Optional<T>> for_each_scope_accessible_unqualified_from_scope(types::ScopeId const scope_id, Function<ErrorOr<typename utility::IterationDecision<T>>(types::ScopeId, JaktInternal::Optional<DeprecatedString>, bool)> const& callback) const;
-ErrorOr<JaktInternal::Optional<types::TraitId>> find_trait_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
-NonnullRefPtr<types::CheckedTrait> get_trait(types::TraitId const id) const;
-ErrorOr<DeprecatedString> type_name(types::TypeId const type_id, bool const debug_mode) const;
-ErrorOr<JaktInternal::Optional<JaktInternal::DynamicArray<types::FunctionId>>> find_functions_with_name_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
-ErrorOr<JaktInternal::Optional<NonnullRefPtr<types::CheckedVariable>>> find_var_in_scope(types::ScopeId const scope_id, DeprecatedString const var) const;
-ErrorOr<JaktInternal::Optional<types::FunctionId>> find_function_in_scope(types::ScopeId const parent_scope_id, DeprecatedString const function_name) const;
-types::CheckedStruct get_struct(types::StructId const id) const;
-ErrorOr<JaktInternal::Optional<types::StructId>> check_and_extract_weak_ptr(types::StructId const struct_id, JaktInternal::DynamicArray<types::TypeId> const args) const;
-ErrorOr<JaktInternal::Optional<types::EnumId>> find_enum_in_scope(types::ScopeId const scope_id, DeprecatedString const name) const;
-JaktInternal::Optional<types::LoadedModule> get_loaded_module(DeprecatedString const module_name) const;
-bool is_numeric(types::TypeId const type_id) const;
-NonnullRefPtr<types::CheckedVariable> get_variable(types::VarId const id) const;
-ErrorOr<types::StructOrEnumId> find_reflected_primitive(DeprecatedString const primitive) const;
-ErrorOr<NonnullRefPtr<types::Scope>> get_scope(types::ScopeId const id) const;
-ErrorOr<DeprecatedString> debug_description() const;
-};struct StructId {
-  public:
-types::ModuleId module;size_t id;bool equals(types::StructId const rhs) const;
-StructId(types::ModuleId a_module, size_t a_id);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace StructLikeId_Details {
-struct Struct{
-JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> generic_arguments;
-types::StructId value;
+struct GenericEnumInstance {
+types::EnumId id;
+JaktInternal::DynamicArray<types::TypeId> args;
 template<typename _MemberT0, typename _MemberT1>
-Struct(_MemberT0&& member_0, _MemberT1&& member_1):
-generic_arguments{ forward<_MemberT0>(member_0)},
-value{ forward<_MemberT1>(member_1)}
+GenericEnumInstance(_MemberT0&& member_0, _MemberT1&& member_1):
+id{ forward<_MemberT0>(member_0)},
+args{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Enum{
-JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> generic_arguments;
-types::EnumId value;
+struct GenericTraitInstance {
+types::TraitId id;
+JaktInternal::DynamicArray<types::TypeId> args;
 template<typename _MemberT0, typename _MemberT1>
-Enum(_MemberT0&& member_0, _MemberT1&& member_1):
-generic_arguments{ forward<_MemberT0>(member_0)},
-value{ forward<_MemberT1>(member_1)}
+GenericTraitInstance(_MemberT0&& member_0, _MemberT1&& member_1):
+id{ forward<_MemberT0>(member_0)},
+args{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Trait{
-JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> generic_arguments;
-types::TraitId value;
+struct GenericResolvedType {
+types::StructId id;
+JaktInternal::DynamicArray<types::TypeId> args;
 template<typename _MemberT0, typename _MemberT1>
-Trait(_MemberT0&& member_0, _MemberT1&& member_1):
-generic_arguments{ forward<_MemberT0>(member_0)},
-value{ forward<_MemberT1>(member_1)}
+GenericResolvedType(_MemberT0&& member_0, _MemberT1&& member_1):
+id{ forward<_MemberT0>(member_0)},
+args{ forward<_MemberT1>(member_1)}
 {}
 };
-}
-struct StructLikeId : public Variant<StructLikeId_Details::Struct, StructLikeId_Details::Enum, StructLikeId_Details::Trait> {
-using Variant<StructLikeId_Details::Struct, StructLikeId_Details::Enum, StructLikeId_Details::Trait>::Variant;
-    using Struct = StructLikeId_Details::Struct;
-    using Enum = StructLikeId_Details::Enum;
-    using Trait = StructLikeId_Details::Trait;
-ErrorOr<DeprecatedString> debug_description() const;
-JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const& generic_arguments() const { switch(this->index()) {case 0 /* Struct */: return this->template get<StructLikeId::Struct>().generic_arguments;
-case 1 /* Enum */: return this->template get<StructLikeId::Enum>().generic_arguments;
-case 2 /* Trait */: return this->template get<StructLikeId::Trait>().generic_arguments;
-default: VERIFY_NOT_REACHED();
-}
-}
-ErrorOr<JaktInternal::DynamicArray<types::TypeId>> generic_parameters(NonnullRefPtr<types::CheckedProgram> const& program) const;
-};
-namespace StructOrEnumId_Details {
 struct Struct{
 types::StructId value;
 template<typename _MemberT0>
@@ -1371,53 +1462,197 @@ Enum(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-}
-struct StructOrEnumId : public Variant<StructOrEnumId_Details::Struct, StructOrEnumId_Details::Enum> {
-using Variant<StructOrEnumId_Details::Struct, StructOrEnumId_Details::Enum>::Variant;
-    using Struct = StructOrEnumId_Details::Struct;
-    using Enum = StructOrEnumId_Details::Enum;
-ErrorOr<DeprecatedString> debug_description() const;
-};
-struct CheckedStruct {
-  public:
-DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters;JaktInternal::DynamicArray<types::CheckedField> fields;types::ScopeId scope_id;parser::DefinitionLinkage definition_linkage;JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> trait_implementations;parser::RecordType record_type;types::TypeId type_id;JaktInternal::Optional<types::StructId> super_struct_id;JaktInternal::Optional<DeprecatedString> external_name;CheckedStruct(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<types::CheckedField> a_fields, types::ScopeId a_scope_id, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> a_trait_implementations, parser::RecordType a_record_type, types::TypeId a_type_id, JaktInternal::Optional<types::StructId> a_super_struct_id, JaktInternal::Optional<DeprecatedString> a_external_name);
-
-DeprecatedString name_for_codegen() const;
-ErrorOr<DeprecatedString> debug_description() const;
-};struct Value {
-  public:
-NonnullRefPtr<typename types::ValueImpl> impl;utility::Span span;ErrorOr<types::Value> copy() const;
-Value(NonnullRefPtr<typename types::ValueImpl> a_impl, utility::Span a_span);
-
-ErrorOr<types::Value> cast(types::Value const expected, utility::Span const span) const;
-DeprecatedString type_name() const;
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace ValueImpl_Details {
-struct Void {
-};
-struct Bool{
-bool value;
+struct RawPtr{
+types::TypeId value;
 template<typename _MemberT0>
-Bool(_MemberT0&& member_0):
+RawPtr(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct U8{
-u8 value;
+struct Trait{
+types::TraitId value;
 template<typename _MemberT0>
-U8(_MemberT0&& member_0):
+Trait(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct U16{
-u16 value;
+struct Reference{
+types::TypeId value;
 template<typename _MemberT0>
-U16(_MemberT0&& member_0):
+Reference(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct U32{
-u32 value;
+struct MutableReference{
+types::TypeId value;
+template<typename _MemberT0>
+MutableReference(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct Function {
+JaktInternal::DynamicArray<types::TypeId> params;
+bool can_throw;
+types::TypeId return_type_id;
+types::FunctionId pseudo_function_id;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+Function(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+params{ forward<_MemberT0>(member_0)},
+can_throw{ forward<_MemberT1>(member_1)},
+return_type_id{ forward<_MemberT2>(member_2)},
+pseudo_function_id{ forward<_MemberT3>(member_3)}
+{}
+};
+struct Self {
+};
+}
+struct Type : public Variant<Type_Details::Void, Type_Details::Bool, Type_Details::U8, Type_Details::U16, Type_Details::U32, Type_Details::U64, Type_Details::I8, Type_Details::I16, Type_Details::I32, Type_Details::I64, Type_Details::F32, Type_Details::F64, Type_Details::Usize, Type_Details::JaktString, Type_Details::CChar, Type_Details::CInt, Type_Details::Unknown, Type_Details::Never, Type_Details::TypeVariable, Type_Details::GenericInstance, Type_Details::GenericEnumInstance, Type_Details::GenericTraitInstance, Type_Details::GenericResolvedType, Type_Details::Struct, Type_Details::Enum, Type_Details::RawPtr, Type_Details::Trait, Type_Details::Reference, Type_Details::MutableReference, Type_Details::Function, Type_Details::Self>, public RefCounted<Type> {
+using Variant<Type_Details::Void, Type_Details::Bool, Type_Details::U8, Type_Details::U16, Type_Details::U32, Type_Details::U64, Type_Details::I8, Type_Details::I16, Type_Details::I32, Type_Details::I64, Type_Details::F32, Type_Details::F64, Type_Details::Usize, Type_Details::JaktString, Type_Details::CChar, Type_Details::CInt, Type_Details::Unknown, Type_Details::Never, Type_Details::TypeVariable, Type_Details::GenericInstance, Type_Details::GenericEnumInstance, Type_Details::GenericTraitInstance, Type_Details::GenericResolvedType, Type_Details::Struct, Type_Details::Enum, Type_Details::RawPtr, Type_Details::Trait, Type_Details::Reference, Type_Details::MutableReference, Type_Details::Function, Type_Details::Self>::Variant;
+    using Void = Type_Details::Void;
+    using Bool = Type_Details::Bool;
+    using U8 = Type_Details::U8;
+    using U16 = Type_Details::U16;
+    using U32 = Type_Details::U32;
+    using U64 = Type_Details::U64;
+    using I8 = Type_Details::I8;
+    using I16 = Type_Details::I16;
+    using I32 = Type_Details::I32;
+    using I64 = Type_Details::I64;
+    using F32 = Type_Details::F32;
+    using F64 = Type_Details::F64;
+    using Usize = Type_Details::Usize;
+    using JaktString = Type_Details::JaktString;
+    using CChar = Type_Details::CChar;
+    using CInt = Type_Details::CInt;
+    using Unknown = Type_Details::Unknown;
+    using Never = Type_Details::Never;
+    using TypeVariable = Type_Details::TypeVariable;
+    using GenericInstance = Type_Details::GenericInstance;
+    using GenericEnumInstance = Type_Details::GenericEnumInstance;
+    using GenericTraitInstance = Type_Details::GenericTraitInstance;
+    using GenericResolvedType = Type_Details::GenericResolvedType;
+    using Struct = Type_Details::Struct;
+    using Enum = Type_Details::Enum;
+    using RawPtr = Type_Details::RawPtr;
+    using Trait = Type_Details::Trait;
+    using Reference = Type_Details::Reference;
+    using MutableReference = Type_Details::MutableReference;
+    using Function = Type_Details::Function;
+    using Self = Type_Details::Self;
+template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
+return adopt_nonnull_ref_or_enomem(new (nothrow) Type(V(forward<Args>(args)...)));
+}
+ErrorOr<DeprecatedString> debug_description() const;
+u64 max() const;
+bool equals(NonnullRefPtr<typename types::Type> const rhs) const;
+DeprecatedString constructor_name() const;
+bool is_concrete() const;
+i64 get_bits() const;
+i64 specificity(NonnullRefPtr<types::CheckedProgram> const program, i64 const base_specificity) const;
+bool is_builtin() const;
+i64 min() const;
+ErrorOr<types::TypeId> flip_signedness() const;
+bool is_boxed(NonnullRefPtr<types::CheckedProgram> const program) const;
+bool is_signed() const;
+};
+namespace SafetyMode_Details {
+struct Safe {
+};
+struct Unsafe {
+};
+}
+struct SafetyMode : public Variant<SafetyMode_Details::Safe, SafetyMode_Details::Unsafe> {
+using Variant<SafetyMode_Details::Safe, SafetyMode_Details::Unsafe>::Variant;
+    using Safe = SafetyMode_Details::Safe;
+    using Unsafe = SafetyMode_Details::Unsafe;
+ErrorOr<DeprecatedString> debug_description() const;
+};
+namespace NumberConstant_Details {
+struct Signed{
+i64 value;
+template<typename _MemberT0>
+Signed(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct Unsigned{
+u64 value;
+template<typename _MemberT0>
+Unsigned(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct Floating{
+f64 value;
+template<typename _MemberT0>
+Floating(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+}
+struct NumberConstant : public Variant<NumberConstant_Details::Signed, NumberConstant_Details::Unsigned, NumberConstant_Details::Floating> {
+using Variant<NumberConstant_Details::Signed, NumberConstant_Details::Unsigned, NumberConstant_Details::Floating>::Variant;
+    using Signed = NumberConstant_Details::Signed;
+    using Unsigned = NumberConstant_Details::Unsigned;
+    using Floating = NumberConstant_Details::Floating;
+ErrorOr<DeprecatedString> debug_description() const;
+bool can_fit_number(types::TypeId const type_id, NonnullRefPtr<types::CheckedProgram> const program) const;
+size_t to_usize() const;
+};
+class TypecheckFunctions : public RefCounted<TypecheckFunctions>, public Weakable<TypecheckFunctions> {
+  public:
+virtual ~TypecheckFunctions() = default;
+Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> block;protected:
+explicit TypecheckFunctions(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> a_block);
+public:
+static ErrorOr<NonnullRefPtr<TypecheckFunctions>> __jakt_create(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> block);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace FunctionGenericParameterKind_Details {
+struct InferenceGuide {
+};
+struct Parameter {
+};
+}
+struct FunctionGenericParameterKind : public Variant<FunctionGenericParameterKind_Details::InferenceGuide, FunctionGenericParameterKind_Details::Parameter> {
+using Variant<FunctionGenericParameterKind_Details::InferenceGuide, FunctionGenericParameterKind_Details::Parameter>::Variant;
+    using InferenceGuide = FunctionGenericParameterKind_Details::InferenceGuide;
+    using Parameter = FunctionGenericParameterKind_Details::Parameter;
+ErrorOr<DeprecatedString> debug_description() const;
+};
+struct FunctionGenericParameter {
+  public:
+types::FunctionGenericParameterKind kind;types::CheckedGenericParameter checked_parameter;static ErrorOr<types::FunctionGenericParameter> parameter(types::TypeId const type_id, utility::Span const span);
+types::TypeId type_id() const;
+FunctionGenericParameter(types::FunctionGenericParameterKind a_kind, types::CheckedGenericParameter a_checked_parameter);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace ValueImpl_Details {
+struct Void {
+};
+struct Bool{
+bool value;
+template<typename _MemberT0>
+Bool(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct U8{
+u8 value;
+template<typename _MemberT0>
+U8(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct U16{
+u16 value;
+template<typename _MemberT0>
+U16(_MemberT0&& member_0):
+value{ forward<_MemberT0>(member_0)}
+{}
+};
+struct U32{
+u32 value;
 template<typename _MemberT0>
 U32(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
@@ -1653,499 +1888,265 @@ ErrorOr<DeprecatedString> debug_description() const;
 bool equals(NonnullRefPtr<typename types::ValueImpl> const other) const;
 ErrorOr<NonnullRefPtr<typename types::ValueImpl>> copy() const;
 };
-namespace CheckedMatchBody_Details {
-struct Expression{
-NonnullRefPtr<typename types::CheckedExpression> value;
-template<typename _MemberT0>
-Expression(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-struct Block{
-types::CheckedBlock value;
-template<typename _MemberT0>
-Block(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-}
-struct CheckedMatchBody : public Variant<CheckedMatchBody_Details::Expression, CheckedMatchBody_Details::Block> {
-using Variant<CheckedMatchBody_Details::Expression, CheckedMatchBody_Details::Block>::Variant;
-    using Expression = CheckedMatchBody_Details::Expression;
-    using Block = CheckedMatchBody_Details::Block;
+struct LoadedModule {
+  public:
+types::ModuleId module_id;utility::FileId file_id;LoadedModule(types::ModuleId a_module_id, utility::FileId a_file_id);
+
 ErrorOr<DeprecatedString> debug_description() const;
-};
-struct CheckedGenericParameter {
+};struct CheckedStruct {
+  public:
+DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters;JaktInternal::DynamicArray<types::CheckedField> fields;types::ScopeId scope_id;parser::DefinitionLinkage definition_linkage;JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> trait_implementations;parser::RecordType record_type;types::TypeId type_id;JaktInternal::Optional<types::StructId> super_struct_id;JaktInternal::Optional<DeprecatedString> external_name;CheckedStruct(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<types::CheckedField> a_fields, types::ScopeId a_scope_id, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> a_trait_implementations, parser::RecordType a_record_type, types::TypeId a_type_id, JaktInternal::Optional<types::StructId> a_super_struct_id, JaktInternal::Optional<DeprecatedString> a_external_name);
+
+DeprecatedString name_for_codegen() const;
+ErrorOr<DeprecatedString> debug_description() const;
+};class CheckedTrait : public RefCounted<CheckedTrait>, public Weakable<CheckedTrait> {
   public:
-types::TypeId type_id;JaktInternal::DynamicArray<types::TraitId> constraints;utility::Span span;CheckedGenericParameter(types::TypeId a_type_id, JaktInternal::DynamicArray<types::TraitId> a_constraints, utility::Span a_span);
+virtual ~CheckedTrait() = default;
+DeprecatedString name;utility::Span name_span;JaktInternal::Dictionary<DeprecatedString,types::FunctionId> methods;JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters;types::ScopeId scope_id;protected:
+explicit CheckedTrait(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> a_methods, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, types::ScopeId a_scope_id);
+public:
+static ErrorOr<NonnullRefPtr<CheckedTrait>> __jakt_create(DeprecatedString name, utility::Span name_span, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> methods, JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters, types::ScopeId scope_id);
 
-static ErrorOr<types::CheckedGenericParameter> make(types::TypeId const type_id, utility::Span const span);
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace MaybeResolvedScope_Details {
-struct Resolved{
-types::ScopeId value;
-template<typename _MemberT0>
-Resolved(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+};struct CheckedVarDecl {
+  public:
+DeprecatedString name;bool is_mutable;utility::Span span;types::TypeId type_id;CheckedVarDecl(DeprecatedString a_name, bool a_is_mutable, utility::Span a_span, types::TypeId a_type_id);
+
+ErrorOr<DeprecatedString> debug_description() const;
+};struct GenericInferences {
+  public:
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> values;ErrorOr<void> set_all(JaktInternal::DynamicArray<types::CheckedGenericParameter> const keys, JaktInternal::DynamicArray<types::TypeId> const values);
+DeprecatedString map_name(DeprecatedString const type) const;
+ErrorOr<void> set_from(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint);
+GenericInferences(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> a_values);
+
+void restore(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint);
+ErrorOr<types::TypeId> map(types::TypeId const type_id) const;
+ErrorOr<JaktInternal::Dictionary<DeprecatedString,DeprecatedString>> perform_checkpoint(bool const reset);
+JaktInternal::Optional<DeprecatedString> get(DeprecatedString const key) const;
+JaktInternal::Dictionary<DeprecatedString,DeprecatedString> iterator() const;
+ErrorOr<void> set(DeprecatedString const key, DeprecatedString const value);
+ErrorOr<DeprecatedString> debug_description() const;
+};namespace CheckedStatement_Details {
+struct Expression {
+NonnullRefPtr<typename types::CheckedExpression> expr;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Expression(_MemberT0&& member_0, _MemberT1&& member_1):
+expr{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Unresolved {
-NonnullRefPtr<typename types::MaybeResolvedScope> parent_scope;
-DeprecatedString relative_name;
+struct Defer {
+NonnullRefPtr<typename types::CheckedStatement> statement;
+utility::Span span;
 template<typename _MemberT0, typename _MemberT1>
-Unresolved(_MemberT0&& member_0, _MemberT1&& member_1):
-parent_scope{ forward<_MemberT0>(member_0)},
-relative_name{ forward<_MemberT1>(member_1)}
+Defer(_MemberT0&& member_0, _MemberT1&& member_1):
+statement{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-}
-struct MaybeResolvedScope : public Variant<MaybeResolvedScope_Details::Resolved, MaybeResolvedScope_Details::Unresolved>, public RefCounted<MaybeResolvedScope> {
-using Variant<MaybeResolvedScope_Details::Resolved, MaybeResolvedScope_Details::Unresolved>::Variant;
-    using Resolved = MaybeResolvedScope_Details::Resolved;
-    using Unresolved = MaybeResolvedScope_Details::Unresolved;
-template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
-return adopt_nonnull_ref_or_enomem(new (nothrow) MaybeResolvedScope(V(forward<Args>(args)...)));
-}
-ErrorOr<DeprecatedString> debug_description() const;
-ErrorOr<NonnullRefPtr<typename types::MaybeResolvedScope>> try_resolve(NonnullRefPtr<types::CheckedProgram> const program) const;
-};
-namespace Type_Details {
-struct Void {
-};
-struct Bool {
-};
-struct U8 {
-};
-struct U16 {
-};
-struct U32 {
-};
-struct U64 {
-};
-struct I8 {
-};
-struct I16 {
-};
-struct I32 {
-};
-struct I64 {
-};
-struct F32 {
-};
-struct F64 {
-};
-struct Usize {
-};
-struct JaktString {
-};
-struct CChar {
-};
-struct CInt {
-};
-struct Unknown {
+struct DestructuringAssignment {
+JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> vars;
+NonnullRefPtr<typename types::CheckedStatement> var_decl;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+DestructuringAssignment(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+vars{ forward<_MemberT0>(member_0)},
+var_decl{ forward<_MemberT1>(member_1)},
+span{ forward<_MemberT2>(member_2)}
+{}
 };
-struct Never {
+struct VarDecl {
+types::VarId var_id;
+NonnullRefPtr<typename types::CheckedExpression> init;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+VarDecl(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+var_id{ forward<_MemberT0>(member_0)},
+init{ forward<_MemberT1>(member_1)},
+span{ forward<_MemberT2>(member_2)}
+{}
 };
-struct TypeVariable {
-DeprecatedString name;
-JaktInternal::DynamicArray<types::TypeId> trait_implementations;
-template<typename _MemberT0, typename _MemberT1>
-TypeVariable(_MemberT0&& member_0, _MemberT1&& member_1):
-name{ forward<_MemberT0>(member_0)},
-trait_implementations{ forward<_MemberT1>(member_1)}
+struct If {
+NonnullRefPtr<typename types::CheckedExpression> condition;
+types::CheckedBlock then_block;
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> else_statement;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
+If(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
+condition{ forward<_MemberT0>(member_0)},
+then_block{ forward<_MemberT1>(member_1)},
+else_statement{ forward<_MemberT2>(member_2)},
+span{ forward<_MemberT3>(member_3)}
 {}
 };
-struct GenericInstance {
-types::StructId id;
-JaktInternal::DynamicArray<types::TypeId> args;
+struct Block {
+types::CheckedBlock block;
+utility::Span span;
 template<typename _MemberT0, typename _MemberT1>
-GenericInstance(_MemberT0&& member_0, _MemberT1&& member_1):
-id{ forward<_MemberT0>(member_0)},
-args{ forward<_MemberT1>(member_1)}
+Block(_MemberT0&& member_0, _MemberT1&& member_1):
+block{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct GenericEnumInstance {
-types::EnumId id;
-JaktInternal::DynamicArray<types::TypeId> args;
+struct Loop {
+types::CheckedBlock block;
+utility::Span span;
 template<typename _MemberT0, typename _MemberT1>
-GenericEnumInstance(_MemberT0&& member_0, _MemberT1&& member_1):
-id{ forward<_MemberT0>(member_0)},
-args{ forward<_MemberT1>(member_1)}
+Loop(_MemberT0&& member_0, _MemberT1&& member_1):
+block{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct GenericTraitInstance {
-types::TraitId id;
-JaktInternal::DynamicArray<types::TypeId> args;
-template<typename _MemberT0, typename _MemberT1>
-GenericTraitInstance(_MemberT0&& member_0, _MemberT1&& member_1):
-id{ forward<_MemberT0>(member_0)},
-args{ forward<_MemberT1>(member_1)}
+struct While {
+NonnullRefPtr<typename types::CheckedExpression> condition;
+types::CheckedBlock block;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1, typename _MemberT2>
+While(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2):
+condition{ forward<_MemberT0>(member_0)},
+block{ forward<_MemberT1>(member_1)},
+span{ forward<_MemberT2>(member_2)}
 {}
 };
-struct GenericResolvedType {
-types::StructId id;
-JaktInternal::DynamicArray<types::TypeId> args;
+struct Return {
+JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> val;
+JaktInternal::Optional<utility::Span> span;
 template<typename _MemberT0, typename _MemberT1>
-GenericResolvedType(_MemberT0&& member_0, _MemberT1&& member_1):
-id{ forward<_MemberT0>(member_0)},
-args{ forward<_MemberT1>(member_1)}
+Return(_MemberT0&& member_0, _MemberT1&& member_1):
+val{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Struct{
-types::StructId value;
+struct Break{
+utility::Span value;
 template<typename _MemberT0>
-Struct(_MemberT0&& member_0):
+Break(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Enum{
-types::EnumId value;
+struct Continue{
+utility::Span value;
 template<typename _MemberT0>
-Enum(_MemberT0&& member_0):
+Continue(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct RawPtr{
-types::TypeId value;
-template<typename _MemberT0>
-RawPtr(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct Throw {
+NonnullRefPtr<typename types::CheckedExpression> expr;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Throw(_MemberT0&& member_0, _MemberT1&& member_1):
+expr{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Trait{
-types::TraitId value;
-template<typename _MemberT0>
-Trait(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct Yield {
+NonnullRefPtr<typename types::CheckedExpression> expr;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+Yield(_MemberT0&& member_0, _MemberT1&& member_1):
+expr{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Reference{
-types::TypeId value;
-template<typename _MemberT0>
-Reference(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct InlineCpp {
+JaktInternal::DynamicArray<DeprecatedString> lines;
+utility::Span span;
+template<typename _MemberT0, typename _MemberT1>
+InlineCpp(_MemberT0&& member_0, _MemberT1&& member_1):
+lines{ forward<_MemberT0>(member_0)},
+span{ forward<_MemberT1>(member_1)}
 {}
 };
-struct MutableReference{
-types::TypeId value;
+struct Garbage{
+utility::Span value;
 template<typename _MemberT0>
-MutableReference(_MemberT0&& member_0):
+Garbage(_MemberT0&& member_0):
 value{ forward<_MemberT0>(member_0)}
 {}
 };
-struct Function {
-JaktInternal::DynamicArray<types::TypeId> params;
-bool can_throw;
-types::TypeId return_type_id;
-types::FunctionId pseudo_function_id;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-Function(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-params{ forward<_MemberT0>(member_0)},
-can_throw{ forward<_MemberT1>(member_1)},
-return_type_id{ forward<_MemberT2>(member_2)},
-pseudo_function_id{ forward<_MemberT3>(member_3)}
-{}
-};
-struct Self {
-};
 }
-struct Type : public Variant<Type_Details::Void, Type_Details::Bool, Type_Details::U8, Type_Details::U16, Type_Details::U32, Type_Details::U64, Type_Details::I8, Type_Details::I16, Type_Details::I32, Type_Details::I64, Type_Details::F32, Type_Details::F64, Type_Details::Usize, Type_Details::JaktString, Type_Details::CChar, Type_Details::CInt, Type_Details::Unknown, Type_Details::Never, Type_Details::TypeVariable, Type_Details::GenericInstance, Type_Details::GenericEnumInstance, Type_Details::GenericTraitInstance, Type_Details::GenericResolvedType, Type_Details::Struct, Type_Details::Enum, Type_Details::RawPtr, Type_Details::Trait, Type_Details::Reference, Type_Details::MutableReference, Type_Details::Function, Type_Details::Self>, public RefCounted<Type> {
-using Variant<Type_Details::Void, Type_Details::Bool, Type_Details::U8, Type_Details::U16, Type_Details::U32, Type_Details::U64, Type_Details::I8, Type_Details::I16, Type_Details::I32, Type_Details::I64, Type_Details::F32, Type_Details::F64, Type_Details::Usize, Type_Details::JaktString, Type_Details::CChar, Type_Details::CInt, Type_Details::Unknown, Type_Details::Never, Type_Details::TypeVariable, Type_Details::GenericInstance, Type_Details::GenericEnumInstance, Type_Details::GenericTraitInstance, Type_Details::GenericResolvedType, Type_Details::Struct, Type_Details::Enum, Type_Details::RawPtr, Type_Details::Trait, Type_Details::Reference, Type_Details::MutableReference, Type_Details::Function, Type_Details::Self>::Variant;
-    using Void = Type_Details::Void;
-    using Bool = Type_Details::Bool;
-    using U8 = Type_Details::U8;
-    using U16 = Type_Details::U16;
-    using U32 = Type_Details::U32;
-    using U64 = Type_Details::U64;
-    using I8 = Type_Details::I8;
-    using I16 = Type_Details::I16;
-    using I32 = Type_Details::I32;
-    using I64 = Type_Details::I64;
-    using F32 = Type_Details::F32;
-    using F64 = Type_Details::F64;
-    using Usize = Type_Details::Usize;
-    using JaktString = Type_Details::JaktString;
-    using CChar = Type_Details::CChar;
-    using CInt = Type_Details::CInt;
-    using Unknown = Type_Details::Unknown;
-    using Never = Type_Details::Never;
-    using TypeVariable = Type_Details::TypeVariable;
-    using GenericInstance = Type_Details::GenericInstance;
-    using GenericEnumInstance = Type_Details::GenericEnumInstance;
-    using GenericTraitInstance = Type_Details::GenericTraitInstance;
-    using GenericResolvedType = Type_Details::GenericResolvedType;
-    using Struct = Type_Details::Struct;
-    using Enum = Type_Details::Enum;
-    using RawPtr = Type_Details::RawPtr;
-    using Trait = Type_Details::Trait;
-    using Reference = Type_Details::Reference;
-    using MutableReference = Type_Details::MutableReference;
-    using Function = Type_Details::Function;
-    using Self = Type_Details::Self;
+struct CheckedStatement : public Variant<CheckedStatement_Details::Expression, CheckedStatement_Details::Defer, CheckedStatement_Details::DestructuringAssignment, CheckedStatement_Details::VarDecl, CheckedStatement_Details::If, CheckedStatement_Details::Block, CheckedStatement_Details::Loop, CheckedStatement_Details::While, CheckedStatement_Details::Return, CheckedStatement_Details::Break, CheckedStatement_Details::Continue, CheckedStatement_Details::Throw, CheckedStatement_Details::Yield, CheckedStatement_Details::InlineCpp, CheckedStatement_Details::Garbage>, public RefCounted<CheckedStatement> {
+using Variant<CheckedStatement_Details::Expression, CheckedStatement_Details::Defer, CheckedStatement_Details::DestructuringAssignment, CheckedStatement_Details::VarDecl, CheckedStatement_Details::If, CheckedStatement_Details::Block, CheckedStatement_Details::Loop, CheckedStatement_Details::While, CheckedStatement_Details::Return, CheckedStatement_Details::Break, CheckedStatement_Details::Continue, CheckedStatement_Details::Throw, CheckedStatement_Details::Yield, CheckedStatement_Details::InlineCpp, CheckedStatement_Details::Garbage>::Variant;
+    using Expression = CheckedStatement_Details::Expression;
+    using Defer = CheckedStatement_Details::Defer;
+    using DestructuringAssignment = CheckedStatement_Details::DestructuringAssignment;
+    using VarDecl = CheckedStatement_Details::VarDecl;
+    using If = CheckedStatement_Details::If;
+    using Block = CheckedStatement_Details::Block;
+    using Loop = CheckedStatement_Details::Loop;
+    using While = CheckedStatement_Details::While;
+    using Return = CheckedStatement_Details::Return;
+    using Break = CheckedStatement_Details::Break;
+    using Continue = CheckedStatement_Details::Continue;
+    using Throw = CheckedStatement_Details::Throw;
+    using Yield = CheckedStatement_Details::Yield;
+    using InlineCpp = CheckedStatement_Details::InlineCpp;
+    using Garbage = CheckedStatement_Details::Garbage;
 template<typename V, typename... Args> static auto __jakt_create(Args&&... args) {
-return adopt_nonnull_ref_or_enomem(new (nothrow) Type(V(forward<Args>(args)...)));
-}
-ErrorOr<DeprecatedString> debug_description() const;
-bool equals(NonnullRefPtr<typename types::Type> const rhs) const;
-i64 get_bits() const;
-i64 specificity(NonnullRefPtr<types::CheckedProgram> const program, i64 const base_specificity) const;
-bool is_concrete() const;
-bool is_builtin() const;
-ErrorOr<types::TypeId> flip_signedness() const;
-u64 max() const;
-DeprecatedString constructor_name() const;
-i64 min() const;
-bool is_signed() const;
-};
-struct CheckedVarDecl {
-  public:
-DeprecatedString name;bool is_mutable;utility::Span span;types::TypeId type_id;CheckedVarDecl(DeprecatedString a_name, bool a_is_mutable, utility::Span a_span, types::TypeId a_type_id);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct ResolvedNamespace {
-  public:
-DeprecatedString name;JaktInternal::Optional<DeprecatedString> external_name;JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> generic_parameters;ResolvedNamespace(DeprecatedString a_name, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> a_generic_parameters);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct CheckedParameter {
-  public:
-bool requires_label;NonnullRefPtr<types::CheckedVariable> variable;JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value;ErrorOr<types::CheckedParameter> map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map) const;
-CheckedParameter(bool a_requires_label, NonnullRefPtr<types::CheckedVariable> a_variable, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> a_default_value);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};class CheckedTrait : public RefCounted<CheckedTrait>, public Weakable<CheckedTrait> {
-  public:
-virtual ~CheckedTrait() = default;
-DeprecatedString name;utility::Span name_span;JaktInternal::Dictionary<DeprecatedString,types::FunctionId> methods;JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters;types::ScopeId scope_id;protected:
-explicit CheckedTrait(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> a_methods, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, types::ScopeId a_scope_id);
-public:
-static ErrorOr<NonnullRefPtr<CheckedTrait>> __jakt_create(DeprecatedString name, utility::Span name_span, JaktInternal::Dictionary<DeprecatedString,types::FunctionId> methods, JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters, types::ScopeId scope_id);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace FunctionGenericParameterKind_Details {
-struct InferenceGuide {
-};
-struct Parameter {
-};
-}
-struct FunctionGenericParameterKind : public Variant<FunctionGenericParameterKind_Details::InferenceGuide, FunctionGenericParameterKind_Details::Parameter> {
-using Variant<FunctionGenericParameterKind_Details::InferenceGuide, FunctionGenericParameterKind_Details::Parameter>::Variant;
-    using InferenceGuide = FunctionGenericParameterKind_Details::InferenceGuide;
-    using Parameter = FunctionGenericParameterKind_Details::Parameter;
-ErrorOr<DeprecatedString> debug_description() const;
-};
-struct FunctionGenericParameter {
-  public:
-types::FunctionGenericParameterKind kind;types::CheckedGenericParameter checked_parameter;static ErrorOr<types::FunctionGenericParameter> parameter(types::TypeId const type_id, utility::Span const span);
-types::TypeId type_id() const;
-FunctionGenericParameter(types::FunctionGenericParameterKind a_kind, types::CheckedGenericParameter a_checked_parameter);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace NumericOrStringValue_Details {
-struct StringValue{
-DeprecatedString value;
-template<typename _MemberT0>
-StringValue(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-struct SignedNumericValue{
-i64 value;
-template<typename _MemberT0>
-SignedNumericValue(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
-struct UnsignedNumericValue{
-u64 value;
-template<typename _MemberT0>
-UnsignedNumericValue(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
-{}
-};
+return adopt_nonnull_ref_or_enomem(new (nothrow) CheckedStatement(V(forward<Args>(args)...)));
 }
-struct NumericOrStringValue : public Variant<NumericOrStringValue_Details::StringValue, NumericOrStringValue_Details::SignedNumericValue, NumericOrStringValue_Details::UnsignedNumericValue> {
-using Variant<NumericOrStringValue_Details::StringValue, NumericOrStringValue_Details::SignedNumericValue, NumericOrStringValue_Details::UnsignedNumericValue>::Variant;
-    using StringValue = NumericOrStringValue_Details::StringValue;
-    using SignedNumericValue = NumericOrStringValue_Details::SignedNumericValue;
-    using UnsignedNumericValue = NumericOrStringValue_Details::UnsignedNumericValue;
 ErrorOr<DeprecatedString> debug_description() const;
+JaktInternal::Optional<utility::Span> span() const;
+static JaktInternal::Optional<NonnullRefPtr<typename types::CheckedStatement>> none();
 };
-class Module : public RefCounted<Module>, public Weakable<Module> {
+class Scope : public RefCounted<Scope>, public Weakable<Scope> {
   public:
-virtual ~Module() = default;
-types::ModuleId id;DeprecatedString name;JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> functions;JaktInternal::DynamicArray<types::CheckedStruct> structures;JaktInternal::DynamicArray<types::CheckedEnum> enums;JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> scopes;JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> types;JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> traits;JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> variables;JaktInternal::DynamicArray<types::ModuleId> imports;DeprecatedString resolved_import_path;bool is_root;protected:
-explicit Module(types::ModuleId a_id, DeprecatedString a_name, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> a_functions, JaktInternal::DynamicArray<types::CheckedStruct> a_structures, JaktInternal::DynamicArray<types::CheckedEnum> a_enums, JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> a_scopes, JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> a_types, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> a_traits, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> a_variables, JaktInternal::DynamicArray<types::ModuleId> a_imports, DeprecatedString a_resolved_import_path, bool a_is_root);
+virtual ~Scope() = default;
+JaktInternal::Optional<DeprecatedString> namespace_name;JaktInternal::Optional<DeprecatedString> external_name;JaktInternal::Dictionary<DeprecatedString,types::VarId> vars;JaktInternal::Dictionary<DeprecatedString,types::Value> comptime_bindings;JaktInternal::Dictionary<DeprecatedString,types::StructId> structs;JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> functions;JaktInternal::Dictionary<DeprecatedString,types::EnumId> enums;JaktInternal::Dictionary<DeprecatedString,types::TypeId> types;JaktInternal::Dictionary<DeprecatedString,types::TraitId> traits;JaktInternal::Dictionary<DeprecatedString,types::ModuleId> imports;JaktInternal::Dictionary<DeprecatedString,types::ScopeId> aliases;JaktInternal::Optional<types::ScopeId> parent;JaktInternal::Optional<types::ScopeId> alias_scope;JaktInternal::DynamicArray<types::ScopeId> children;bool can_throw;JaktInternal::Optional<DeprecatedString> import_path_if_extern;JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> alias_path;JaktInternal::DynamicArray<parser::IncludeAction> after_extern_include;JaktInternal::DynamicArray<parser::IncludeAction> before_extern_include;DeprecatedString debug_name;JaktInternal::DynamicArray<types::ScopeId> resolution_mixins;bool is_block_scope;protected:
+explicit Scope(JaktInternal::Optional<DeprecatedString> a_namespace_name, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Dictionary<DeprecatedString,types::VarId> a_vars, JaktInternal::Dictionary<DeprecatedString,types::Value> a_comptime_bindings, JaktInternal::Dictionary<DeprecatedString,types::StructId> a_structs, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> a_functions, JaktInternal::Dictionary<DeprecatedString,types::EnumId> a_enums, JaktInternal::Dictionary<DeprecatedString,types::TypeId> a_types, JaktInternal::Dictionary<DeprecatedString,types::TraitId> a_traits, JaktInternal::Dictionary<DeprecatedString,types::ModuleId> a_imports, JaktInternal::Dictionary<DeprecatedString,types::ScopeId> a_aliases, JaktInternal::Optional<types::ScopeId> a_parent, JaktInternal::Optional<types::ScopeId> a_alias_scope, JaktInternal::DynamicArray<types::ScopeId> a_children, bool a_can_throw, JaktInternal::Optional<DeprecatedString> a_import_path_if_extern, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> a_alias_path, JaktInternal::DynamicArray<parser::IncludeAction> a_after_extern_include, JaktInternal::DynamicArray<parser::IncludeAction> a_before_extern_include, DeprecatedString a_debug_name, JaktInternal::DynamicArray<types::ScopeId> a_resolution_mixins, bool a_is_block_scope);
 public:
-static ErrorOr<NonnullRefPtr<Module>> __jakt_create(types::ModuleId id, DeprecatedString name, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedFunction>> functions, JaktInternal::DynamicArray<types::CheckedStruct> structures, JaktInternal::DynamicArray<types::CheckedEnum> enums, JaktInternal::DynamicArray<NonnullRefPtr<types::Scope>> scopes, JaktInternal::DynamicArray<NonnullRefPtr<typename types::Type>> types, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedTrait>> traits, JaktInternal::DynamicArray<NonnullRefPtr<types::CheckedVariable>> variables, JaktInternal::DynamicArray<types::ModuleId> imports, DeprecatedString resolved_import_path, bool is_root);
-
-ErrorOr<types::TypeId> new_type_variable(JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const implemented_traits);
-ErrorOr<types::FunctionId> add_function(NonnullRefPtr<types::CheckedFunction> const checked_function);
-bool is_prelude() const;
-ErrorOr<types::VarId> add_variable(NonnullRefPtr<types::CheckedVariable> const checked_variable);
-types::FunctionId next_function_id() const;
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace CheckedMatchCase_Details {
-struct EnumVariant {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults;
-DeprecatedString name;
-JaktInternal::DynamicArray<parser::EnumVariantPatternArgument> args;
-types::TypeId subject_type_id;
-size_t index;
-types::ScopeId scope_id;
-types::CheckedMatchBody body;
-utility::Span marker_span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3, typename _MemberT4, typename _MemberT5, typename _MemberT6, typename _MemberT7>
-EnumVariant(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3, _MemberT4&& member_4, _MemberT5&& member_5, _MemberT6&& member_6, _MemberT7&& member_7):
-defaults{ forward<_MemberT0>(member_0)},
-name{ forward<_MemberT1>(member_1)},
-args{ forward<_MemberT2>(member_2)},
-subject_type_id{ forward<_MemberT3>(member_3)},
-index{ forward<_MemberT4>(member_4)},
-scope_id{ forward<_MemberT5>(member_5)},
-body{ forward<_MemberT6>(member_6)},
-marker_span{ forward<_MemberT7>(member_7)}
-{}
-};
-struct Expression {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults;
-NonnullRefPtr<typename types::CheckedExpression> expression;
-types::CheckedMatchBody body;
-utility::Span marker_span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-Expression(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-defaults{ forward<_MemberT0>(member_0)},
-expression{ forward<_MemberT1>(member_1)},
-body{ forward<_MemberT2>(member_2)},
-marker_span{ forward<_MemberT3>(member_3)}
-{}
-};
-struct CatchAll {
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> defaults;
-bool has_arguments;
-types::CheckedMatchBody body;
-utility::Span marker_span;
-template<typename _MemberT0, typename _MemberT1, typename _MemberT2, typename _MemberT3>
-CatchAll(_MemberT0&& member_0, _MemberT1&& member_1, _MemberT2&& member_2, _MemberT3&& member_3):
-defaults{ forward<_MemberT0>(member_0)},
-has_arguments{ forward<_MemberT1>(member_1)},
-body{ forward<_MemberT2>(member_2)},
-marker_span{ forward<_MemberT3>(member_3)}
-{}
-};
-}
-struct CheckedMatchCase : public Variant<CheckedMatchCase_Details::EnumVariant, CheckedMatchCase_Details::Expression, CheckedMatchCase_Details::CatchAll> {
-using Variant<CheckedMatchCase_Details::EnumVariant, CheckedMatchCase_Details::Expression, CheckedMatchCase_Details::CatchAll>::Variant;
-    using EnumVariant = CheckedMatchCase_Details::EnumVariant;
-    using Expression = CheckedMatchCase_Details::Expression;
-    using CatchAll = CheckedMatchCase_Details::CatchAll;
-ErrorOr<DeprecatedString> debug_description() const;
-JaktInternal::DynamicArray<NonnullRefPtr<typename types::CheckedStatement>> const& defaults() const { switch(this->index()) {case 0 /* EnumVariant */: return this->template get<CheckedMatchCase::EnumVariant>().defaults;
-case 1 /* Expression */: return this->template get<CheckedMatchCase::Expression>().defaults;
-case 2 /* CatchAll */: return this->template get<CheckedMatchCase::CatchAll>().defaults;
-default: VERIFY_NOT_REACHED();
-}
-}
-};
-struct CheckedField {
-  public:
-types::VarId variable_id;JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> default_value;JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> default_value_expression;CheckedField(types::VarId a_variable_id, JaktInternal::Optional<NonnullRefPtr<typename types::CheckedExpression>> a_default_value, JaktInternal::Optional<NonnullRefPtr<typename parser::ParsedExpression>> a_default_value_expression);
+static ErrorOr<NonnullRefPtr<Scope>> __jakt_create(JaktInternal::Optional<DeprecatedString> namespace_name, JaktInternal::Optional<DeprecatedString> external_name, JaktInternal::Dictionary<DeprecatedString,types::VarId> vars, JaktInternal::Dictionary<DeprecatedString,types::Value> comptime_bindings, JaktInternal::Dictionary<DeprecatedString,types::StructId> structs, JaktInternal::Dictionary<DeprecatedString,JaktInternal::DynamicArray<types::FunctionId>> functions, JaktInternal::Dictionary<DeprecatedString,types::EnumId> enums, JaktInternal::Dictionary<DeprecatedString,types::TypeId> types, JaktInternal::Dictionary<DeprecatedString,types::TraitId> traits, JaktInternal::Dictionary<DeprecatedString,types::ModuleId> imports, JaktInternal::Dictionary<DeprecatedString,types::ScopeId> aliases, JaktInternal::Optional<types::ScopeId> parent, JaktInternal::Optional<types::ScopeId> alias_scope, JaktInternal::DynamicArray<types::ScopeId> children, bool can_throw, JaktInternal::Optional<DeprecatedString> import_path_if_extern, JaktInternal::Optional<JaktInternal::DynamicArray<types::ResolvedNamespace>> alias_path, JaktInternal::DynamicArray<parser::IncludeAction> after_extern_include, JaktInternal::DynamicArray<parser::IncludeAction> before_extern_include, DeprecatedString debug_name, JaktInternal::DynamicArray<types::ScopeId> resolution_mixins, bool is_block_scope);
 
 ErrorOr<DeprecatedString> debug_description() const;
-};namespace NumberConstant_Details {
-struct Signed{
-i64 value;
-template<typename _MemberT0>
-Signed(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+};namespace StructLikeId_Details {
+struct Struct{
+JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> generic_arguments;
+types::StructId value;
+template<typename _MemberT0, typename _MemberT1>
+Struct(_MemberT0&& member_0, _MemberT1&& member_1):
+generic_arguments{ forward<_MemberT0>(member_0)},
+value{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Unsigned{
-u64 value;
-template<typename _MemberT0>
-Unsigned(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct Enum{
+JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> generic_arguments;
+types::EnumId value;
+template<typename _MemberT0, typename _MemberT1>
+Enum(_MemberT0&& member_0, _MemberT1&& member_1):
+generic_arguments{ forward<_MemberT0>(member_0)},
+value{ forward<_MemberT1>(member_1)}
 {}
 };
-struct Floating{
-f64 value;
-template<typename _MemberT0>
-Floating(_MemberT0&& member_0):
-value{ forward<_MemberT0>(member_0)}
+struct Trait{
+JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> generic_arguments;
+types::TraitId value;
+template<typename _MemberT0, typename _MemberT1>
+Trait(_MemberT0&& member_0, _MemberT1&& member_1):
+generic_arguments{ forward<_MemberT0>(member_0)},
+value{ forward<_MemberT1>(member_1)}
 {}
 };
-}
-struct NumberConstant : public Variant<NumberConstant_Details::Signed, NumberConstant_Details::Unsigned, NumberConstant_Details::Floating> {
-using Variant<NumberConstant_Details::Signed, NumberConstant_Details::Unsigned, NumberConstant_Details::Floating>::Variant;
-    using Signed = NumberConstant_Details::Signed;
-    using Unsigned = NumberConstant_Details::Unsigned;
-    using Floating = NumberConstant_Details::Floating;
-ErrorOr<DeprecatedString> debug_description() const;
-size_t to_usize() const;
-bool can_fit_number(types::TypeId const type_id, NonnullRefPtr<types::CheckedProgram> const program) const;
-};
-struct FieldRecord {
-  public:
-types::StructId struct_id;types::VarId field_id;FieldRecord(types::StructId a_struct_id, types::VarId a_field_id);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace SafetyMode_Details {
-struct Safe {
-};
-struct Unsafe {
-};
-}
-struct SafetyMode : public Variant<SafetyMode_Details::Safe, SafetyMode_Details::Unsafe> {
-using Variant<SafetyMode_Details::Safe, SafetyMode_Details::Unsafe>::Variant;
-    using Safe = SafetyMode_Details::Safe;
-    using Unsafe = SafetyMode_Details::Unsafe;
-ErrorOr<DeprecatedString> debug_description() const;
-};
-class CheckedFunction : public RefCounted<CheckedFunction>, public Weakable<CheckedFunction> {
-  public:
-virtual ~CheckedFunction() = default;
-DeprecatedString name;utility::Span name_span;types::CheckedVisibility visibility;types::TypeId return_type_id;JaktInternal::Optional<utility::Span> return_type_span;JaktInternal::DynamicArray<types::CheckedParameter> params;NonnullRefPtr<types::FunctionGenerics> generics;types::CheckedBlock block;bool can_throw;parser::FunctionType type;parser::FunctionLinkage linkage;types::ScopeId function_scope_id;JaktInternal::Optional<types::StructId> struct_id;bool is_instantiated;JaktInternal::Optional<parser::ParsedFunction> parsed_function;bool is_comptime;bool is_virtual;bool is_override;JaktInternal::Optional<size_t> specialization_index;JaktInternal::Optional<types::ScopeId> owner_scope;JaktInternal::Optional<DeprecatedString> external_name;JaktInternal::Optional<DeprecatedString> deprecated_message;JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> stores_arguments;ErrorOr<bool> signature_matches(NonnullRefPtr<types::CheckedFunction> const other) const;
-bool is_static() const;
-protected:
-explicit CheckedFunction(DeprecatedString a_name, utility::Span a_name_span, types::CheckedVisibility a_visibility, types::TypeId a_return_type_id, JaktInternal::Optional<utility::Span> a_return_type_span, JaktInternal::DynamicArray<types::CheckedParameter> a_params, NonnullRefPtr<types::FunctionGenerics> a_generics, types::CheckedBlock a_block, bool a_can_throw, parser::FunctionType a_type, parser::FunctionLinkage a_linkage, types::ScopeId a_function_scope_id, JaktInternal::Optional<types::StructId> a_struct_id, bool a_is_instantiated, JaktInternal::Optional<parser::ParsedFunction> a_parsed_function, bool a_is_comptime, bool a_is_virtual, bool a_is_override, JaktInternal::Optional<size_t> a_specialization_index, JaktInternal::Optional<types::ScopeId> a_owner_scope, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Optional<DeprecatedString> a_deprecated_message, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> a_stores_arguments);
-public:
-static ErrorOr<NonnullRefPtr<CheckedFunction>> __jakt_create(DeprecatedString name, utility::Span name_span, types::CheckedVisibility visibility, types::TypeId return_type_id, JaktInternal::Optional<utility::Span> return_type_span, JaktInternal::DynamicArray<types::CheckedParameter> params, NonnullRefPtr<types::FunctionGenerics> generics, types::CheckedBlock block, bool can_throw, parser::FunctionType type, parser::FunctionLinkage linkage, types::ScopeId function_scope_id, JaktInternal::Optional<types::StructId> struct_id, bool is_instantiated, JaktInternal::Optional<parser::ParsedFunction> parsed_function, bool is_comptime, bool is_virtual, bool is_override, JaktInternal::Optional<size_t> specialization_index, JaktInternal::Optional<types::ScopeId> owner_scope, JaktInternal::Optional<DeprecatedString> external_name, JaktInternal::Optional<DeprecatedString> deprecated_message, JaktInternal::Optional<JaktInternal::DynamicArray<JaktInternal::Tuple<size_t,parser::ArgumentStoreLevel>>> stores_arguments);
-
-parser::ParsedFunction to_parsed_function() const;
-bool is_specialized_for_types(JaktInternal::DynamicArray<types::TypeId> const types) const;
-ErrorOr<NonnullRefPtr<types::CheckedFunction>> copy() const;
-ErrorOr<void> add_param(types::CheckedParameter const checked_param);
-ErrorOr<void> map_types(Function<ErrorOr<types::TypeId>(types::TypeId)> const& map);
-bool is_mutating() const;
-DeprecatedString name_for_codegen() const;
-ErrorOr<void> set_params(JaktInternal::DynamicArray<types::CheckedParameter> const checked_params);
-ErrorOr<DeprecatedString> debug_description() const;
-};class TypecheckFunctions : public RefCounted<TypecheckFunctions>, public Weakable<TypecheckFunctions> {
-  public:
-virtual ~TypecheckFunctions() = default;
-Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> block;protected:
-explicit TypecheckFunctions(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> a_block);
-public:
-static ErrorOr<NonnullRefPtr<TypecheckFunctions>> __jakt_create(Function<ErrorOr<types::CheckedBlock>(parser::ParsedBlock, types::ScopeId, types::SafetyMode, JaktInternal::Optional<types::TypeId>)> block);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};struct GenericInferences {
-  public:
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> values;DeprecatedString map_name(DeprecatedString const type) const;
-GenericInferences(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> a_values);
-
-void restore(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint);
-ErrorOr<types::TypeId> map(types::TypeId const type_id) const;
-JaktInternal::Dictionary<DeprecatedString,DeprecatedString> iterator() const;
-ErrorOr<void> set(DeprecatedString const key, DeprecatedString const value);
-ErrorOr<void> set_all(JaktInternal::DynamicArray<types::CheckedGenericParameter> const keys, JaktInternal::DynamicArray<types::TypeId> const values);
-ErrorOr<void> set_from(JaktInternal::Dictionary<DeprecatedString,DeprecatedString> const checkpoint);
-JaktInternal::Optional<DeprecatedString> get(DeprecatedString const key) const;
-ErrorOr<JaktInternal::Dictionary<DeprecatedString,DeprecatedString>> perform_checkpoint(bool const reset);
+}
+struct StructLikeId : public Variant<StructLikeId_Details::Struct, StructLikeId_Details::Enum, StructLikeId_Details::Trait> {
+using Variant<StructLikeId_Details::Struct, StructLikeId_Details::Enum, StructLikeId_Details::Trait>::Variant;
+    using Struct = StructLikeId_Details::Struct;
+    using Enum = StructLikeId_Details::Enum;
+    using Trait = StructLikeId_Details::Trait;
 ErrorOr<DeprecatedString> debug_description() const;
-};struct CheckedEnum {
+JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> const& generic_arguments() const { switch(this->index()) {case 0 /* Struct */: return this->template get<StructLikeId::Struct>().generic_arguments;
+case 1 /* Enum */: return this->template get<StructLikeId::Enum>().generic_arguments;
+case 2 /* Trait */: return this->template get<StructLikeId::Trait>().generic_arguments;
+default: VERIFY_NOT_REACHED();
+}
+}
+ErrorOr<JaktInternal::DynamicArray<types::TypeId>> generic_parameters(NonnullRefPtr<types::CheckedProgram> const& program) const;
+};
+struct ResolvedNamespace {
   public:
-DeprecatedString name;utility::Span name_span;JaktInternal::DynamicArray<types::CheckedGenericParameter> generic_parameters;JaktInternal::DynamicArray<types::CheckedEnumVariant> variants;JaktInternal::DynamicArray<types::CheckedField> fields;types::ScopeId scope_id;parser::DefinitionLinkage definition_linkage;JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> trait_implementations;parser::RecordType record_type;types::TypeId underlying_type_id;types::TypeId type_id;bool is_boxed;CheckedEnum(DeprecatedString a_name, utility::Span a_name_span, JaktInternal::DynamicArray<types::CheckedGenericParameter> a_generic_parameters, JaktInternal::DynamicArray<types::CheckedEnumVariant> a_variants, JaktInternal::DynamicArray<types::CheckedField> a_fields, types::ScopeId a_scope_id, parser::DefinitionLinkage a_definition_linkage, JaktInternal::Dictionary<DeprecatedString,JaktInternal::Tuple<types::TraitId,JaktInternal::DynamicArray<types::TypeId>>> a_trait_implementations, parser::RecordType a_record_type, types::TypeId a_underlying_type_id, types::TypeId a_type_id, bool a_is_boxed);
+DeprecatedString name;JaktInternal::Optional<DeprecatedString> external_name;JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> generic_parameters;ResolvedNamespace(DeprecatedString a_name, JaktInternal::Optional<DeprecatedString> a_external_name, JaktInternal::Optional<JaktInternal::DynamicArray<types::TypeId>> a_generic_parameters);
 
 ErrorOr<DeprecatedString> debug_description() const;
 };}
@@ -2156,50 +2157,56 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
+template<>struct Jakt::Formatter<Jakt::types::Module> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::Module const& value) {
+JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
+};
+namespace Jakt {
+} // namespace Jakt
 template<>struct Jakt::Formatter<Jakt::types::ScopeId> : Jakt::Formatter<Jakt::StringView>{
 Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::ScopeId const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::BlockControlFlow> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::BlockControlFlow const& value) {
+template<>struct Jakt::Formatter<Jakt::types::MaybeResolvedScope> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::MaybeResolvedScope const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::TypeId> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::TypeId const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedVisibility> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedVisibility const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedBlock> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedBlock const& value) {
+template<>struct Jakt::Formatter<Jakt::types::TypeId> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::TypeId const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedTypeCast> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedTypeCast const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedEnum> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedEnum const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedNumericConstant> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedNumericConstant const& value) {
+template<>struct Jakt::Formatter<Jakt::types::VarId> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::VarId const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::StringLiteral> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::StringLiteral const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedField> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedField const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedStringLiteral> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedStringLiteral const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedCapture> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedCapture const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
@@ -2216,188 +2223,188 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedUnaryOperator> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedUnaryOperator const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedParameter> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedParameter const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedEnumVariantBinding> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedEnumVariantBinding const& value) {
+template<>struct Jakt::Formatter<Jakt::types::BlockControlFlow> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::BlockControlFlow const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::FunctionId> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::FunctionId const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedBlock> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedBlock const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedCall> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedCall const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedMatchBody> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedMatchBody const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedVisibility> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedVisibility const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedMatchCase> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedMatchCase const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedVariable> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedVariable const& value) {
+template<>struct Jakt::Formatter<Jakt::types::NumericOrStringValue> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::NumericOrStringValue const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::VarId> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::VarId const& value) {
+template<>struct Jakt::Formatter<Jakt::types::BuiltinType> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::BuiltinType const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedStatement> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedStatement const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedVariable> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedVariable const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedExpression> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedExpression const& value) {
+template<>struct Jakt::Formatter<Jakt::types::TraitId> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::TraitId const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::LoadedModule> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::LoadedModule const& value) {
+template<>struct Jakt::Formatter<Jakt::types::FunctionId> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::FunctionId const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::TraitId> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::TraitId const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedCall> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedCall const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::BuiltinType> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::BuiltinType const& value) {
+template<>struct Jakt::Formatter<Jakt::types::Value> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::Value const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedCapture> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedCapture const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedGenericParameter> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedGenericParameter const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedNamespace> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedNamespace const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedProgram> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedProgram const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::Scope> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::Scope const& value) {
+template<>struct Jakt::Formatter<Jakt::types::StructId> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::StructId const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::FunctionGenerics> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::FunctionGenerics const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedFunction> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedFunction const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedProgram> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedProgram const& value) {
+template<>struct Jakt::Formatter<Jakt::types::FieldRecord> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::FieldRecord const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::StructId> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::StructId const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedNumericConstant> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedNumericConstant const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::StructLikeId> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::StructLikeId const& value) {
+template<>struct Jakt::Formatter<Jakt::types::StringLiteral> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::StringLiteral const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::StructOrEnumId> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::StructOrEnumId const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedStringLiteral> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedStringLiteral const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedStruct> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedStruct const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedTypeCast> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedTypeCast const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::Value> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::Value const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedUnaryOperator> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedUnaryOperator const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::ValueImpl> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::ValueImpl const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedEnumVariantBinding> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedEnumVariantBinding const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedMatchBody> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedMatchBody const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedExpression> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedExpression const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedGenericParameter> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedGenericParameter const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedNamespace> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedNamespace const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::MaybeResolvedScope> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::MaybeResolvedScope const& value) {
+template<>struct Jakt::Formatter<Jakt::types::StructOrEnumId> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::StructOrEnumId const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::Type> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::Type const& value) {
+template<>struct Jakt::Formatter<Jakt::types::FunctionGenerics> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::FunctionGenerics const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedVarDecl> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedVarDecl const& value) {
+template<>struct Jakt::Formatter<Jakt::types::Type> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::Type const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::ResolvedNamespace> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::ResolvedNamespace const& value) {
+template<>struct Jakt::Formatter<Jakt::types::SafetyMode> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::SafetyMode const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedParameter> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedParameter const& value) {
+template<>struct Jakt::Formatter<Jakt::types::NumberConstant> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::NumberConstant const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedTrait> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedTrait const& value) {
+template<>struct Jakt::Formatter<Jakt::types::TypecheckFunctions> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::TypecheckFunctions const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
@@ -2414,68 +2421,62 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::NumericOrStringValue> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::NumericOrStringValue const& value) {
-JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
-};
-namespace Jakt {
-} // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::Module> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::Module const& value) {
+template<>struct Jakt::Formatter<Jakt::types::ValueImpl> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::ValueImpl const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedMatchCase> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedMatchCase const& value) {
+template<>struct Jakt::Formatter<Jakt::types::LoadedModule> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::LoadedModule const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedField> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedField const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedStruct> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedStruct const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::NumberConstant> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::NumberConstant const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedTrait> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedTrait const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::FieldRecord> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::FieldRecord const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedVarDecl> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedVarDecl const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::SafetyMode> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::SafetyMode const& value) {
+template<>struct Jakt::Formatter<Jakt::types::GenericInferences> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::GenericInferences const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedFunction> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedFunction const& value) {
+template<>struct Jakt::Formatter<Jakt::types::CheckedStatement> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedStatement const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::TypecheckFunctions> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::TypecheckFunctions const& value) {
+template<>struct Jakt::Formatter<Jakt::types::Scope> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::Scope const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::GenericInferences> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::GenericInferences const& value) {
+template<>struct Jakt::Formatter<Jakt::types::StructLikeId> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::StructLikeId const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::types::CheckedEnum> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::CheckedEnum const& value) {
+template<>struct Jakt::Formatter<Jakt::types::ResolvedNamespace> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::types::ResolvedNamespace const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
 };
 namespace Jakt {
diff --git a/bootstrap/stage0/utility.cpp b/bootstrap/stage0/utility.cpp
index d293f76a0..53d446f96 100644
--- a/bootstrap/stage0/utility.cpp
+++ b/bootstrap/stage0/utility.cpp
@@ -1,9 +1,25 @@
 #include "utility.h"
 namespace Jakt {
 namespace utility {
-bool is_ascii_binary(u8 const c) {
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> append_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings,DeprecatedString const suffix) {
 {
-return (((c == '0') || (c == '1')));
+JaktInternal::DynamicArray<DeprecatedString> output = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+{
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((strings).iterator());
+for (;;){
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+DeprecatedString str = (_magic_value.value());
+{
+TRY((((output).push((str + suffix)))));
+}
+
+}
+}
+
+return (output);
 }
 }
 
@@ -19,9 +35,22 @@ return ((((byte == ' ') || (byte == '\t')) || (byte == '\r')));
 }
 }
 
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> prepend_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings,DeprecatedString const prefix) {
+bool is_ascii_digit(u8 const c) {
 {
-JaktInternal::DynamicArray<DeprecatedString> output = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
+return (((c >= '0') && (c <= '9')));
+}
+}
+
+bool is_ascii_alphanumeric(u8 const c) {
+{
+return ((utility::is_ascii_alpha(c) || utility::is_ascii_digit(c)));
+}
+}
+
+DeprecatedString join(JaktInternal::DynamicArray<DeprecatedString> const strings,DeprecatedString const separator) {
+{
+DeprecatedString output = Jakt::DeprecatedString(""sv);
+size_t i = static_cast<size_t>(0ULL);
 {
 JaktInternal::ArrayIterator<DeprecatedString> _magic = ((strings).iterator());
 for (;;){
@@ -29,9 +58,13 @@ JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-DeprecatedString str = (_magic_value.value());
+DeprecatedString s = (_magic_value.value());
 {
-TRY((((output).push((prefix + str)))));
+(output += s);
+if ((i < (JaktInternal::checked_sub<size_t>(((strings).size()),static_cast<size_t>(1ULL))))){
+(output += separator);
+}
+((i++));
 }
 
 }
@@ -41,12 +74,30 @@ return (output);
 }
 }
 
-bool is_ascii_digit(u8 const c) {
+ErrorOr<void> write_to_file(DeprecatedString const data,DeprecatedString const output_filename) {
 {
-return (((c >= '0') && (c <= '9')));
+NonnullRefPtr<File> outfile = TRY((File::open_for_writing(output_filename)));
+JaktInternal::DynamicArray<u8> bytes = (TRY((DynamicArray<u8>::create_with({}))));
+{
+JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((data).length()))});
+for (;;){
+JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+if ((!(((_magic_value).has_value())))){
+break;
+}
+size_t i = (_magic_value.value());
+{
+TRY((((bytes).push(((data).byte_at(i))))));
+}
+
 }
 }
 
+TRY((((outfile)->write(bytes))));
+}
+return {};
+}
+
 void todo(DeprecatedString const message) {
 {
 warnln(Jakt::DeprecatedString("TODO: {}"sv),message);
@@ -54,16 +105,15 @@ abort();
 }
 }
 
-bool is_ascii_alphanumeric(u8 const c) {
+bool is_ascii_octdigit(u8 const c) {
 {
-return ((utility::is_ascii_alpha(c) || utility::is_ascii_digit(c)));
+return (((c >= '0') && (c <= '7')));
 }
 }
 
-ErrorOr<DeprecatedString> interpret_escapes(DeprecatedString const s) {
+ErrorOr<DeprecatedString> escape_for_quotes(DeprecatedString const s) {
 {
 DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
-bool in_escape = false;
 {
 DeprecatedStringCodePointIterator _magic = ((s).code_points());
 for (;;){
@@ -75,50 +125,27 @@ u32 cp = (_magic_value.value());
 {
 JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<DeprecatedString>>{
 auto __jakt_enum_value = (cp);
-if (__jakt_enum_value == (infallible_integer_cast<u32>(('\\')))) {
-{
-if (in_escape){
-TRY((((builder).append('\\'))));
-(in_escape = false);
-}
-else {
-(in_escape = true);
-}
-
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == (infallible_integer_cast<u32>(('"')))) {
+if (__jakt_enum_value == (infallible_integer_cast<u32>(('"')))) {
 {
-TRY((((builder).append_code_point(cp))));
-(in_escape = false);
+TRY((((builder).append_string(Jakt::DeprecatedString("\\\""sv)))));
 }
 return JaktInternal::ExplicitValue<void>();
 }
-else if (__jakt_enum_value == (infallible_integer_cast<u32>(('\'')))) {
+else if (__jakt_enum_value == (infallible_integer_cast<u32>(('\\')))) {
 {
-TRY((((builder).append_code_point(cp))));
-(in_escape = false);
+TRY((((builder).append_string(Jakt::DeprecatedString("\\\\"sv)))));
 }
 return JaktInternal::ExplicitValue<void>();
 }
-else if (__jakt_enum_value == (infallible_integer_cast<u32>(('n')))) {
+else if (__jakt_enum_value == (infallible_integer_cast<u32>(('\n')))) {
 {
-if (in_escape){
-TRY((((builder).append('\n'))));
-(in_escape = false);
-}
-else {
-TRY((((builder).append_code_point(cp))));
-}
-
+TRY((((builder).append_string(Jakt::DeprecatedString("\\n"sv)))));
 }
 return JaktInternal::ExplicitValue<void>();
 }
 else {
 {
 TRY((((builder).append_code_point(cp))));
-(in_escape = false);
 }
 return JaktInternal::ExplicitValue<void>();
 }
@@ -134,88 +161,83 @@ return (TRY((((builder).to_string()))));
 }
 }
 
-ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> append_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings,DeprecatedString const suffix) {
-{
-JaktInternal::DynamicArray<DeprecatedString> output = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
-{
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((strings).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
-}
-DeprecatedString str = (_magic_value.value());
+bool is_ascii_hexdigit(u8 const c) {
 {
-TRY((((output).push((str + suffix)))));
-}
-
-}
-}
-
-return (output);
+return (((((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f'))) || ((c >= 'A') && (c <= 'F'))));
 }
 }
 
-ErrorOr<void> write_to_file(DeprecatedString const data,DeprecatedString const output_filename) {
+ErrorOr<DeprecatedString> interpret_escapes(DeprecatedString const s) {
 {
-NonnullRefPtr<File> outfile = TRY((File::open_for_writing(output_filename)));
-JaktInternal::DynamicArray<u8> bytes = (TRY((DynamicArray<u8>::create_with({}))));
+DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+bool in_escape = false;
 {
-JaktInternal::Range<size_t> _magic = (JaktInternal::Range<size_t>{static_cast<size_t>(static_cast<size_t>(0ULL)),static_cast<size_t>(((data).length()))});
+DeprecatedStringCodePointIterator _magic = ((s).code_points());
 for (;;){
-JaktInternal::Optional<size_t> const _magic_value = ((_magic).next());
+JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-size_t i = (_magic_value.value());
+u32 cp = (_magic_value.value());
 {
-TRY((((bytes).push(((data).byte_at(i))))));
-}
-
+JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<DeprecatedString>>{
+auto __jakt_enum_value = (cp);
+if (__jakt_enum_value == (infallible_integer_cast<u32>(('\\')))) {
+{
+if (in_escape){
+TRY((((builder).append('\\'))));
+(in_escape = false);
 }
+else {
+(in_escape = true);
 }
 
-TRY((((outfile)->write(bytes))));
 }
-return {};
+return JaktInternal::ExplicitValue<void>();
 }
-
-DeprecatedString join(JaktInternal::DynamicArray<DeprecatedString> const strings,DeprecatedString const separator) {
+else if (__jakt_enum_value == (infallible_integer_cast<u32>(('"')))) {
 {
-DeprecatedString output = Jakt::DeprecatedString(""sv);
-size_t i = static_cast<size_t>(0ULL);
+TRY((((builder).append_code_point(cp))));
+(in_escape = false);
+}
+return JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == (infallible_integer_cast<u32>(('\'')))) {
 {
-JaktInternal::ArrayIterator<DeprecatedString> _magic = ((strings).iterator());
-for (;;){
-JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
-if ((!(((_magic_value).has_value())))){
-break;
+TRY((((builder).append_code_point(cp))));
+(in_escape = false);
 }
-DeprecatedString s = (_magic_value.value());
+return JaktInternal::ExplicitValue<void>();
+}
+else if (__jakt_enum_value == (infallible_integer_cast<u32>(('n')))) {
 {
-(output += s);
-if ((i < (JaktInternal::checked_sub<size_t>(((strings).size()),static_cast<size_t>(1ULL))))){
-(output += separator);
+if (in_escape){
+TRY((((builder).append('\n'))));
+(in_escape = false);
 }
-((i++));
+else {
+TRY((((builder).append_code_point(cp))));
 }
 
 }
+return JaktInternal::ExplicitValue<void>();
 }
-
-return (output);
+else {
+{
+TRY((((builder).append_code_point(cp))));
+(in_escape = false);
 }
+return JaktInternal::ExplicitValue<void>();
+}
+return JaktInternal::ExplicitValue<void>();
+}()))
+;
 }
 
-bool is_ascii_octdigit(u8 const c) {
-{
-return (((c >= '0') && (c <= '7')));
 }
 }
 
-bool is_ascii_hexdigit(u8 const c) {
-{
-return (((((c >= '0') && (c <= '9')) || ((c >= 'a') && (c <= 'f'))) || ((c >= 'A') && (c <= 'F'))));
+return (TRY((((builder).to_string()))));
 }
 }
 
@@ -226,53 +248,31 @@ abort();
 }
 }
 
-ErrorOr<DeprecatedString> escape_for_quotes(DeprecatedString const s) {
+ErrorOr<JaktInternal::DynamicArray<DeprecatedString>> prepend_to_each(JaktInternal::DynamicArray<DeprecatedString> const strings,DeprecatedString const prefix) {
 {
-DeprecatedStringBuilder builder = TRY((DeprecatedStringBuilder::create()));
+JaktInternal::DynamicArray<DeprecatedString> output = (TRY((DynamicArray<DeprecatedString>::create_with({}))));
 {
-DeprecatedStringCodePointIterator _magic = ((s).code_points());
+JaktInternal::ArrayIterator<DeprecatedString> _magic = ((strings).iterator());
 for (;;){
-JaktInternal::Optional<u32> const _magic_value = ((_magic).next());
+JaktInternal::Optional<DeprecatedString> const _magic_value = ((_magic).next());
 if ((!(((_magic_value).has_value())))){
 break;
 }
-u32 cp = (_magic_value.value());
-{
-JAKT_RESOLVE_EXPLICIT_VALUE_OR_CONTROL_FLOW_AT_LOOP(([&]() -> JaktInternal::ExplicitValueOrControlFlow<void,ErrorOr<DeprecatedString>>{
-auto __jakt_enum_value = (cp);
-if (__jakt_enum_value == (infallible_integer_cast<u32>(('"')))) {
-{
-TRY((((builder).append_string(Jakt::DeprecatedString("\\\""sv)))));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == (infallible_integer_cast<u32>(('\\')))) {
-{
-TRY((((builder).append_string(Jakt::DeprecatedString("\\\\"sv)))));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else if (__jakt_enum_value == (infallible_integer_cast<u32>(('\n')))) {
-{
-TRY((((builder).append_string(Jakt::DeprecatedString("\\n"sv)))));
-}
-return JaktInternal::ExplicitValue<void>();
-}
-else {
+DeprecatedString str = (_magic_value.value());
 {
-TRY((((builder).append_code_point(cp))));
+TRY((((output).push((prefix + str)))));
 }
-return JaktInternal::ExplicitValue<void>();
+
 }
-return JaktInternal::ExplicitValue<void>();
-}()))
-;
 }
 
+return (output);
 }
 }
 
-return (TRY((((builder).to_string()))));
+bool is_ascii_binary(u8 const c) {
+{
+return (((c == '0') || (c == '1')));
 }
 }
 
@@ -289,26 +289,26 @@ return ((((((*this).file_id)).equals(((span).file_id))) && ((((span).start) >= (
 }
 }
 
+utility::Span::Span(utility::FileId a_file_id, size_t a_start, size_t a_end) :file_id(move(a_file_id)), start(move(a_start)), end(move(a_end)){}
+
 bool utility::Span::is_in_offset_range(size_t const start,size_t const end) const {
 {
 return (((start <= ((*this).start)) && (end >= ((*this).end))));
 }
 }
 
-utility::Span::Span(utility::FileId a_file_id, size_t a_start, size_t a_end) :file_id(move(a_file_id)), start(move(a_start)), end(move(a_end)){}
-
 ErrorOr<DeprecatedString> utility::FileId::debug_description() const { auto builder = MUST(DeprecatedStringBuilder::create());TRY(builder.append("FileId("sv));{
 JaktInternal::PrettyPrint::ScopedLevelIncrease increase_indent {};
 TRY(JaktInternal::PrettyPrint::output_indentation(builder));TRY(builder.appendff("id: {}", id));
 }
 TRY(builder.append(")"sv));return builder.to_string(); }
+utility::FileId::FileId(size_t a_id) :id(move(a_id)){}
+
 bool utility::FileId::equals(utility::FileId const rhs) const {
 {
 return ((((*this).id) == ((rhs).id)));
 }
 }
 
-utility::FileId::FileId(size_t a_id) :id(move(a_id)){}
-
 }
 } // namespace Jakt
diff --git a/bootstrap/stage0/utility.h b/bootstrap/stage0/utility.h
index e4c02ed7e..7b46785bf 100644
--- a/bootstrap/stage0/utility.h
+++ b/bootstrap/stage0/utility.h
@@ -2,13 +2,7 @@
 #include "__unified_forward.h"
 namespace Jakt {
 namespace utility {
-struct FileId {
-  public:
-size_t id;bool equals(utility::FileId const rhs) const;
-FileId(size_t a_id);
-
-ErrorOr<DeprecatedString> debug_description() const;
-};namespace IterationDecision_Details {
+namespace IterationDecision_Details {
 template<typename T>
 struct Break {
 T value;
@@ -46,27 +40,27 @@ break;}
 return builder.to_string();
 }
 };
-struct Span {
+struct FileId {
+  public:
+size_t id;FileId(size_t a_id);
+
+bool equals(utility::FileId const rhs) const;
+ErrorOr<DeprecatedString> debug_description() const;
+};struct Span {
   public:
 utility::FileId file_id;size_t start;size_t end;bool contains(utility::Span const span) const;
-bool is_in_offset_range(size_t const start, size_t const end) const;
 Span(utility::FileId a_file_id, size_t a_start, size_t a_end);
 
+bool is_in_offset_range(size_t const start, size_t const end) const;
 ErrorOr<DeprecatedString> debug_description() const;
 };template <typename T>
-ErrorOr<JaktInternal::DynamicArray<T>> add_arrays(JaktInternal::DynamicArray<T> const a, JaktInternal::DynamicArray<T> const b);
+T* allocate(size_t const count);
 template <typename T>
 T* null();
 template <typename T>
-T* allocate(size_t const count);
+ErrorOr<JaktInternal::DynamicArray<T>> add_arrays(JaktInternal::DynamicArray<T> const a, JaktInternal::DynamicArray<T> const b);
 }
 } // namespace Jakt
-template<>struct Jakt::Formatter<Jakt::utility::FileId> : Jakt::Formatter<Jakt::StringView>{
-Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::utility::FileId const& value) {
-JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
-};
-namespace Jakt {
-} // namespace Jakt
 template<typename T>struct Jakt::Formatter<Jakt::utility::IterationDecision<T>
 > : Jakt::Formatter<Jakt::StringView>{
 Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::utility::IterationDecision<T>
@@ -75,6 +69,12 @@ JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form
 };
 namespace Jakt {
 } // namespace Jakt
+template<>struct Jakt::Formatter<Jakt::utility::FileId> : Jakt::Formatter<Jakt::StringView>{
+Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::utility::FileId const& value) {
+JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
+};
+namespace Jakt {
+} // namespace Jakt
 template<>struct Jakt::Formatter<Jakt::utility::Span> : Jakt::Formatter<Jakt::StringView>{
 Jakt::ErrorOr<void> format(Jakt::FormatBuilder& builder, Jakt::utility::Span const& value) {
 JaktInternal::PrettyPrint::ScopedEnable pretty_print_enable { m_alternative_form };Jakt::ErrorOr<void> format_error = Jakt::Formatter<Jakt::StringView>::format(builder, MUST(value.debug_description()));return format_error;}
diff --git a/bootstrap/stage0/utility_specializations.cpp b/bootstrap/stage0/utility_specializations.cpp
index 67296eed0..003f4a57b 100644
--- a/bootstrap/stage0/utility_specializations.cpp
+++ b/bootstrap/stage0/utility_specializations.cpp
@@ -29,26 +29,33 @@
 namespace Jakt {
 namespace utility {
 
+/* specialisation 0 of function allocate: ["char"] */
+template<> char* allocate<char>(size_t const count);
+
 /* specialisation 0 of function null: ["FILE"] */
 template<> FILE* null<FILE>();
 
 /* specialisation 1 of function null: ["char"] */
 template<> char* null<char>();
-
-/* specialisation 0 of function allocate: ["char"] */
-template<> char* allocate<char>(size_t const count);
 template<>
-FILE* null<FILE>() {
+char* allocate<char>(size_t const count) {
 {
+Function<void(char*&)> const alloc_impl = [count](char*& ptr) -> void {
 {
-return nullptr;
+{
+ptr = static_cast<RemoveReference<decltype(ptr)>>(calloc(count, sizeof(*ptr)));
 }
 
-abort();
+}
+}
+;
+char* ptr = utility::null<char>();
+alloc_impl(((ptr)));
+return (ptr);
 }
 }
 template<>
-char* null<char>() {
+FILE* null<FILE>() {
 {
 {
 return nullptr;
@@ -58,20 +65,13 @@ abort();
 }
 }
 template<>
-char* allocate<char>(size_t const count) {
-{
-Function<void(char*&)> const alloc_impl = [count](char*& ptr) -> void {
+char* null<char>() {
 {
 {
-ptr = static_cast<RemoveReference<decltype(ptr)>>(calloc(count, sizeof(*ptr)));
+return nullptr;
 }
 
-}
-}
-;
-char* ptr = utility::null<char>();
-alloc_impl(((ptr)));
-return (ptr);
+abort();
 }
 }
 }