Commit 7f0620a20f

@@ -1216,6 +1216,7 @@ enum BuiltinFnId {
     BuiltinFnIdSetGlobalLinkage,
     BuiltinFnIdPanic,
     BuiltinFnIdPtrCast,
+    BuiltinFnIdBitCast,
     BuiltinFnIdIntToPtr,
     BuiltinFnIdEnumTagName,
     BuiltinFnIdFieldParentPtr,
@@ -1800,6 +1801,7 @@ enum IrInstructionId {
     IrInstructionIdTestComptime,
     IrInstructionIdInitEnum,
     IrInstructionIdPtrCast,
+    IrInstructionIdBitCast,
     IrInstructionIdWidenOrShorten,
     IrInstructionIdIntToPtr,
     IrInstructionIdPtrToInt,
@@ -2448,6 +2450,13 @@ struct IrInstructionPtrCast {
     IrInstruction *ptr;
 };
 
+struct IrInstructionBitCast {
+    IrInstruction base;
+
+    IrInstruction *dest_type;
+    IrInstruction *value;
+};
+
 struct IrInstructionWidenOrShorten {
     IrInstruction base;
 

@@ -459,3 +459,77 @@ uint32_t bignum_clz(BigNum *bignum, uint32_t bit_count) {
     }
     return result;
 }
+
+void bignum_write_twos_complement(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian) {
+    assert(bn->kind == BigNumKindInt);
+    uint64_t x = bignum_to_twos_complement(bn);
+
+    int byte_count = (bit_count + 7) / 8;
+    for (int i = 0; i < byte_count; i += 1) {
+        uint8_t le_byte = (x >> (i * 8)) & 0xff;
+        if (is_big_endian) {
+            buf[byte_count - i - 1] = le_byte;
+        } else {
+            buf[i] = le_byte;
+        }
+    }
+}
+
+void bignum_read_twos_complement(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian, bool is_signed) {
+    int byte_count = (bit_count + 7) / 8;
+
+    uint64_t twos_comp = 0;
+    for (int i = 0; i < byte_count; i += 1) {
+        uint8_t be_byte;
+        if (is_big_endian) {
+            be_byte = buf[i];
+        } else {
+            be_byte = buf[byte_count - i - 1];
+        }
+
+        twos_comp <<= 8;
+        twos_comp |= be_byte;
+    }
+
+    uint8_t be_byte = buf[is_big_endian ? 0 : byte_count - 1];
+    if (is_signed && ((be_byte >> 7) & 0x1) != 0) {
+        bn->is_negative = true;
+        uint64_t mask = 0;
+        for (int i = 0; i < bit_count; i += 1) {
+            mask <<= 1;
+            mask |= 1;
+        }
+        bn->data.x_uint = ((~twos_comp) & mask) + 1;
+    } else {
+        bn->data.x_uint = twos_comp;
+    }
+    bn->kind = BigNumKindInt;
+}
+
+void bignum_write_ieee597(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian) {
+    assert(bn->kind == BigNumKindFloat);
+    if (bit_count == 32) {
+        float f32 = bn->data.x_float;
+        memcpy(buf, &f32, 4);
+    } else if (bit_count == 64) {
+        double f64 = bn->data.x_float;
+        memcpy(buf, &f64, 8);
+    } else {
+        zig_unreachable();
+    }
+}
+
+void bignum_read_ieee597(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian) {
+    bn->kind = BigNumKindFloat;
+    if (bit_count == 32) {
+        float f32;
+        memcpy(&f32, buf, 4);
+        bn->data.x_float = f32;
+    } else if (bit_count == 64) {
+        double f64;
+        memcpy(&f64, buf, 8);
+        bn->data.x_float = f64;
+    } else {
+        zig_unreachable();
+    }
+}

@@ -32,6 +32,11 @@ void bignum_init_bignum(BigNum *dest, BigNum *src);
 bool bignum_fits_in_bits(BigNum *bn, int bit_count, bool is_signed);
 uint64_t bignum_to_twos_complement(BigNum *bn);
 
+void bignum_write_twos_complement(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian);
+void bignum_write_ieee597(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian);
+void bignum_read_twos_complement(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian, bool is_signed);
+void bignum_read_ieee597(BigNum *bn, uint8_t *buf, int bit_count, bool is_big_endian);
+
 // returns true if overflow happened
 bool bignum_add(BigNum *dest, BigNum *op1, BigNum *op2);
 bool bignum_sub(BigNum *dest, BigNum *op1, BigNum *op2);

@@ -1693,6 +1693,14 @@ static LLVMValueRef ir_render_ptr_cast(CodeGen *g, IrExecutable *executable,
     return LLVMBuildBitCast(g->builder, ptr, wanted_type->type_ref, "");
 }
 
+static LLVMValueRef ir_render_bit_cast(CodeGen *g, IrExecutable *executable,
+        IrInstructionBitCast *instruction)
+{
+    TypeTableEntry *wanted_type = instruction->base.value.type;
+    LLVMValueRef value = ir_llvm_value(g, instruction->value);
+    return LLVMBuildBitCast(g->builder, value, wanted_type->type_ref, "");
+}
+
 static LLVMValueRef ir_render_widen_or_shorten(CodeGen *g, IrExecutable *executable,
         IrInstructionWidenOrShorten *instruction)
 {
@@ -3180,6 +3188,8 @@ static LLVMValueRef ir_render_instruction(CodeGen *g, IrExecutable *executable,
             return ir_render_struct_init(g, executable, (IrInstructionStructInit *)instruction);
         case IrInstructionIdPtrCast:
             return ir_render_ptr_cast(g, executable, (IrInstructionPtrCast *)instruction);
+        case IrInstructionIdBitCast:
+            return ir_render_bit_cast(g, executable, (IrInstructionBitCast *)instruction);
         case IrInstructionIdWidenOrShorten:
             return ir_render_widen_or_shorten(g, executable, (IrInstructionWidenOrShorten *)instruction);
         case IrInstructionIdPtrToInt:
@@ -4514,6 +4524,7 @@ static void define_builtin_fns(CodeGen *g) {
     create_builtin_fn(g, BuiltinFnIdSetGlobalLinkage, "setGlobalLinkage", 2);
     create_builtin_fn(g, BuiltinFnIdPanic, "panic", 1);
     create_builtin_fn(g, BuiltinFnIdPtrCast, "ptrCast", 2);
+    create_builtin_fn(g, BuiltinFnIdBitCast, "bitCast", 2);
     create_builtin_fn(g, BuiltinFnIdIntToPtr, "intToPtr", 2);
     create_builtin_fn(g, BuiltinFnIdEnumTagName, "enumTagName", 1);
     create_builtin_fn(g, BuiltinFnIdFieldParentPtr, "fieldParentPtr", 3);

@@ -469,6 +469,10 @@ static constexpr IrInstructionId ir_instruction_id(IrInstructionPtrCast *) {
     return IrInstructionIdPtrCast;
 }
 
+static constexpr IrInstructionId ir_instruction_id(IrInstructionBitCast *) {
+    return IrInstructionIdBitCast;
+}
+
 static constexpr IrInstructionId ir_instruction_id(IrInstructionWidenOrShorten *) {
     return IrInstructionIdWidenOrShorten;
 }
@@ -1922,6 +1926,20 @@ static IrInstruction *ir_build_ptr_cast(IrBuilder *irb, Scope *scope, AstNode *s
     return &instruction->base;
 }
 
+static IrInstruction *ir_build_bit_cast(IrBuilder *irb, Scope *scope, AstNode *source_node,
+        IrInstruction *dest_type, IrInstruction *value)
+{
+    IrInstructionBitCast *instruction = ir_build_instruction<IrInstructionBitCast>(
+            irb, scope, source_node);
+    instruction->dest_type = dest_type;
+    instruction->value = value;
+
+    if (dest_type) ir_ref_instruction(dest_type, irb->current_basic_block);
+    ir_ref_instruction(value, irb->current_basic_block);
+
+    return &instruction->base;
+}
+
 static IrInstruction *ir_build_widen_or_shorten(IrBuilder *irb, Scope *scope, AstNode *source_node,
         IrInstruction *target)
 {
@@ -2704,6 +2722,16 @@ static IrInstruction *ir_instruction_ptrcast_get_dep(IrInstructionPtrCast *instr
     }
 }
 
+static IrInstruction *ir_instruction_bitcast_get_dep(IrInstructionBitCast *instruction,
+        size_t index)
+{
+    switch (index) {
+        case 0: return instruction->value;
+        case 1: return instruction->dest_type;
+        default: return nullptr;
+    }
+}
+
 static IrInstruction *ir_instruction_widenorshorten_get_dep(IrInstructionWidenOrShorten *instruction, size_t index) {
     switch (index) {
         case 0: return instruction->target;
@@ -3000,6 +3028,8 @@ static IrInstruction *ir_instruction_get_dep(IrInstruction *instruction, size_t
             return ir_instruction_initenum_get_dep((IrInstructionInitEnum *) instruction, index);
         case IrInstructionIdPtrCast:
             return ir_instruction_ptrcast_get_dep((IrInstructionPtrCast *) instruction, index);
+        case IrInstructionIdBitCast:
+            return ir_instruction_bitcast_get_dep((IrInstructionBitCast *) instruction, index);
         case IrInstructionIdWidenOrShorten:
             return ir_instruction_widenorshorten_get_dep((IrInstructionWidenOrShorten *) instruction, index);
         case IrInstructionIdIntToPtr:
@@ -4301,6 +4331,20 @@ static IrInstruction *ir_gen_builtin_fn_call(IrBuilder *irb, Scope *scope, AstNo
 
                 return ir_build_ptr_cast(irb, scope, node, arg0_value, arg1_value);
             }
+        case BuiltinFnIdBitCast:
+            {
+                AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
+                IrInstruction *arg0_value = ir_gen_node(irb, arg0_node, scope);
+                if (arg0_value == irb->codegen->invalid_instruction)
+                    return arg0_value;
+
+                AstNode *arg1_node = node->data.fn_call_expr.params.at(1);
+                IrInstruction *arg1_value = ir_gen_node(irb, arg1_node, scope);
+                if (arg1_value == irb->codegen->invalid_instruction)
+                    return arg1_value;
+
+                return ir_build_bit_cast(irb, scope, node, arg0_value, arg1_value);
+            }
         case BuiltinFnIdIntToPtr:
             {
                 AstNode *arg0_node = node->data.fn_call_expr.params.at(0);
@@ -13427,6 +13471,222 @@ static TypeTableEntry *ir_analyze_instruction_ptr_cast(IrAnalyze *ira, IrInstruc
     return dest_type;
 }
 
+static void buf_write_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue *val) {
+    assert(val->special == ConstValSpecialStatic);
+    switch (val->type->id) {
+        case TypeTableEntryIdInvalid:
+        case TypeTableEntryIdVar:
+        case TypeTableEntryIdMetaType:
+        case TypeTableEntryIdOpaque:
+        case TypeTableEntryIdBoundFn:
+        case TypeTableEntryIdArgTuple:
+        case TypeTableEntryIdNamespace:
+        case TypeTableEntryIdBlock:
+        case TypeTableEntryIdUnreachable:
+        case TypeTableEntryIdNumLitFloat:
+        case TypeTableEntryIdNumLitInt:
+        case TypeTableEntryIdUndefLit:
+        case TypeTableEntryIdNullLit:
+            zig_unreachable();
+        case TypeTableEntryIdVoid:
+            return;
+        case TypeTableEntryIdBool:
+            buf[0] = val->data.x_bool ? 1 : 0;
+            return;
+        case TypeTableEntryIdInt:
+            bignum_write_twos_complement(&val->data.x_bignum, buf, val->type->data.integral.bit_count, codegen->is_big_endian);
+            return;
+        case TypeTableEntryIdFloat:
+            bignum_write_ieee597(&val->data.x_bignum, buf, val->type->data.floating.bit_count, codegen->is_big_endian);
+            return;
+        case TypeTableEntryIdPointer:
+            if (val->data.x_ptr.special == ConstPtrSpecialHardCodedAddr) {
+                BigNum bn;
+                bignum_init_unsigned(&bn, val->data.x_ptr.data.hard_coded_addr.addr);
+                bignum_write_twos_complement(&bn, buf, codegen->builtin_types.entry_usize->data.integral.bit_count, codegen->is_big_endian);
+                return;
+            } else {
+                zig_unreachable();
+            }
+        case TypeTableEntryIdArray:
+            zig_panic("TODO buf_write_value_bytes array type");
+        case TypeTableEntryIdStruct:
+            zig_panic("TODO buf_write_value_bytes struct type");
+        case TypeTableEntryIdMaybe:
+            zig_panic("TODO buf_write_value_bytes maybe type");
+        case TypeTableEntryIdErrorUnion:
+            zig_panic("TODO buf_write_value_bytes error union");
+        case TypeTableEntryIdPureError:
+            zig_panic("TODO buf_write_value_bytes pure error type");
+        case TypeTableEntryIdEnum:
+            zig_panic("TODO buf_write_value_bytes enum type");
+        case TypeTableEntryIdEnumTag:
+            zig_panic("TODO buf_write_value_bytes enum tag type");
+        case TypeTableEntryIdFn:
+            zig_panic("TODO buf_write_value_bytes fn type");
+        case TypeTableEntryIdUnion:
+            zig_panic("TODO buf_write_value_bytes union type");
+    }
+    zig_unreachable();
+}
+
+static void buf_read_value_bytes(CodeGen *codegen, uint8_t *buf, ConstExprValue *val) {
+    assert(val->special == ConstValSpecialStatic);
+    switch (val->type->id) {
+        case TypeTableEntryIdInvalid:
+        case TypeTableEntryIdVar:
+        case TypeTableEntryIdMetaType:
+        case TypeTableEntryIdOpaque:
+        case TypeTableEntryIdBoundFn:
+        case TypeTableEntryIdArgTuple:
+        case TypeTableEntryIdNamespace:
+        case TypeTableEntryIdBlock:
+        case TypeTableEntryIdUnreachable:
+        case TypeTableEntryIdNumLitFloat:
+        case TypeTableEntryIdNumLitInt:
+        case TypeTableEntryIdUndefLit:
+        case TypeTableEntryIdNullLit:
+            zig_unreachable();
+        case TypeTableEntryIdVoid:
+            return;
+        case TypeTableEntryIdBool:
+            val->data.x_bool = (buf[0] != 0);
+            return;
+        case TypeTableEntryIdInt:
+            bignum_read_twos_complement(&val->data.x_bignum, buf, val->type->data.integral.bit_count, codegen->is_big_endian,
+                    val->type->data.integral.is_signed);
+            return;
+        case TypeTableEntryIdFloat:
+            bignum_read_ieee597(&val->data.x_bignum, buf, val->type->data.floating.bit_count, codegen->is_big_endian);
+            return;
+        case TypeTableEntryIdPointer:
+            {
+                val->data.x_ptr.special = ConstPtrSpecialHardCodedAddr;
+                BigNum bn;
+                bignum_read_twos_complement(&bn, buf, codegen->builtin_types.entry_usize->data.integral.bit_count, codegen->is_big_endian, false);
+                val->data.x_ptr.data.hard_coded_addr.addr = bignum_to_twos_complement(&bn);
+                return;
+            }
+        case TypeTableEntryIdArray:
+            zig_panic("TODO buf_read_value_bytes array type");
+        case TypeTableEntryIdStruct:
+            zig_panic("TODO buf_read_value_bytes struct type");
+        case TypeTableEntryIdMaybe:
+            zig_panic("TODO buf_read_value_bytes maybe type");
+        case TypeTableEntryIdErrorUnion:
+            zig_panic("TODO buf_read_value_bytes error union");
+        case TypeTableEntryIdPureError:
+            zig_panic("TODO buf_read_value_bytes pure error type");
+        case TypeTableEntryIdEnum:
+            zig_panic("TODO buf_read_value_bytes enum type");
+        case TypeTableEntryIdEnumTag:
+            zig_panic("TODO buf_read_value_bytes enum tag type");
+        case TypeTableEntryIdFn:
+            zig_panic("TODO buf_read_value_bytes fn type");
+        case TypeTableEntryIdUnion:
+            zig_panic("TODO buf_read_value_bytes union type");
+    }
+    zig_unreachable();
+}
+
+static TypeTableEntry *ir_analyze_instruction_bit_cast(IrAnalyze *ira, IrInstructionBitCast *instruction) {
+    IrInstruction *dest_type_value = instruction->dest_type->other;
+    TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
+    if (type_is_invalid(dest_type))
+        return ira->codegen->builtin_types.entry_invalid;
+
+    IrInstruction *value = instruction->value->other;
+    TypeTableEntry *src_type = value->value.type;
+    if (type_is_invalid(src_type))
+        return ira->codegen->builtin_types.entry_invalid;
+
+    ensure_complete_type(ira->codegen, dest_type);
+    ensure_complete_type(ira->codegen, src_type);
+
+    if (type_is_codegen_pointer(src_type)) {
+        ir_add_error(ira, value,
+            buf_sprintf("unable to @bitCast from type '%s'", buf_ptr(&src_type->name)));
+        return ira->codegen->builtin_types.entry_invalid;
+    }
+
+    switch (src_type->id) {
+        case TypeTableEntryIdInvalid:
+        case TypeTableEntryIdVar:
+        case TypeTableEntryIdMetaType:
+        case TypeTableEntryIdOpaque:
+        case TypeTableEntryIdBoundFn:
+        case TypeTableEntryIdArgTuple:
+        case TypeTableEntryIdNamespace:
+        case TypeTableEntryIdBlock:
+        case TypeTableEntryIdUnreachable:
+        case TypeTableEntryIdNumLitFloat:
+        case TypeTableEntryIdNumLitInt:
+        case TypeTableEntryIdUndefLit:
+        case TypeTableEntryIdNullLit:
+            ir_add_error(ira, dest_type_value,
+                    buf_sprintf("unable to @bitCast from type '%s'", buf_ptr(&src_type->name)));
+            return ira->codegen->builtin_types.entry_invalid;
+        default:
+            break;
+    }
+
+    if (type_is_codegen_pointer(dest_type)) {
+        ir_add_error(ira, dest_type_value,
+                buf_sprintf("unable to @bitCast to type '%s'", buf_ptr(&dest_type->name)));
+        return ira->codegen->builtin_types.entry_invalid;
+    }
+
+    switch (dest_type->id) {
+        case TypeTableEntryIdInvalid:
+        case TypeTableEntryIdVar:
+        case TypeTableEntryIdMetaType:
+        case TypeTableEntryIdOpaque:
+        case TypeTableEntryIdBoundFn:
+        case TypeTableEntryIdArgTuple:
+        case TypeTableEntryIdNamespace:
+        case TypeTableEntryIdBlock:
+        case TypeTableEntryIdUnreachable:
+        case TypeTableEntryIdNumLitFloat:
+        case TypeTableEntryIdNumLitInt:
+        case TypeTableEntryIdUndefLit:
+        case TypeTableEntryIdNullLit:
+            ir_add_error(ira, dest_type_value,
+                    buf_sprintf("unable to @bitCast to type '%s'", buf_ptr(&dest_type->name)));
+            return ira->codegen->builtin_types.entry_invalid;
+        default:
+            break;
+    }
+
+    uint64_t dest_size_bytes = type_size(ira->codegen, dest_type);
+    uint64_t src_size_bytes = type_size(ira->codegen, src_type);
+    if (dest_size_bytes != src_size_bytes) {
+        ir_add_error(ira, &instruction->base,
+            buf_sprintf("destination type '%s' has size %" ZIG_PRI_u64 " but source type '%s' has size %" ZIG_PRI_u64,
+                buf_ptr(&dest_type->name), dest_size_bytes,
+                buf_ptr(&src_type->name), src_size_bytes));
+        return ira->codegen->builtin_types.entry_invalid;
+    }
+
+    if (instr_is_comptime(value)) {
+        ConstExprValue *val = ir_resolve_const(ira, value, UndefBad);
+        if (!val)
+            return ira->codegen->builtin_types.entry_invalid;
+
+        ConstExprValue *out_val = ir_build_const_from(ira, &instruction->base);
+        out_val->type = dest_type;
+        uint8_t *buf = allocate_nonzero<uint8_t>(src_size_bytes);
+        buf_write_value_bytes(ira->codegen, buf, val);
+        buf_read_value_bytes(ira->codegen, buf, out_val);
+        return dest_type;
+    }
+
+    IrInstruction *result = ir_build_bit_cast(&ira->new_irb, instruction->base.scope,
+            instruction->base.source_node, nullptr, value);
+    ir_link_new_instruction(result, &instruction->base);
+    result->value.type = dest_type;
+    return dest_type;
+}
+
 static TypeTableEntry *ir_analyze_instruction_int_to_ptr(IrAnalyze *ira, IrInstructionIntToPtr *instruction) {
     IrInstruction *dest_type_value = instruction->dest_type->other;
     TypeTableEntry *dest_type = ir_resolve_type(ira, dest_type_value);
@@ -13697,6 +13957,8 @@ static TypeTableEntry *ir_analyze_instruction_nocast(IrAnalyze *ira, IrInstructi
             return ir_analyze_instruction_panic(ira, (IrInstructionPanic *)instruction);
         case IrInstructionIdPtrCast:
             return ir_analyze_instruction_ptr_cast(ira, (IrInstructionPtrCast *)instruction);
+        case IrInstructionIdBitCast:
+            return ir_analyze_instruction_bit_cast(ira, (IrInstructionBitCast *)instruction);
         case IrInstructionIdIntToPtr:
             return ir_analyze_instruction_int_to_ptr(ira, (IrInstructionIntToPtr *)instruction);
         case IrInstructionIdEnumTagName:
@@ -13872,6 +14134,7 @@ bool ir_has_side_effects(IrInstruction *instruction) {
         case IrInstructionIdTestComptime:
         case IrInstructionIdInitEnum:
         case IrInstructionIdPtrCast:
+        case IrInstructionIdBitCast:
         case IrInstructionIdWidenOrShorten:
         case IrInstructionIdPtrToInt:
         case IrInstructionIdIntToPtr:

@@ -756,7 +756,7 @@ static void ir_print_init_enum(IrPrint *irp, IrInstructionInitEnum *instruction)
 }
 
 static void ir_print_ptr_cast(IrPrint *irp, IrInstructionPtrCast *instruction) {
-    fprintf(irp->f, "@ptrcast(");
+    fprintf(irp->f, "@ptrCast(");
     if (instruction->dest_type) {
         ir_print_other_instruction(irp, instruction->dest_type);
     }
@@ -765,6 +765,16 @@ static void ir_print_ptr_cast(IrPrint *irp, IrInstructionPtrCast *instruction) {
     fprintf(irp->f, ")");
 }
 
+static void ir_print_bit_cast(IrPrint *irp, IrInstructionBitCast *instruction) {
+    fprintf(irp->f, "@bitCast(");
+    if (instruction->dest_type) {
+        ir_print_other_instruction(irp, instruction->dest_type);
+    }
+    fprintf(irp->f, ",");
+    ir_print_other_instruction(irp, instruction->value);
+    fprintf(irp->f, ")");
+}
+
 static void ir_print_widen_or_shorten(IrPrint *irp, IrInstructionWidenOrShorten *instruction) {
     fprintf(irp->f, "@widenOrShorten(");
     ir_print_other_instruction(irp, instruction->target);
@@ -1124,6 +1134,9 @@ static void ir_print_instruction(IrPrint *irp, IrInstruction *instruction) {
         case IrInstructionIdPtrCast:
             ir_print_ptr_cast(irp, (IrInstructionPtrCast *)instruction);
             break;
+        case IrInstructionIdBitCast:
+            ir_print_bit_cast(irp, (IrInstructionBitCast *)instruction);
+            break;
         case IrInstructionIdWidenOrShorten:
             ir_print_widen_or_shorten(irp, (IrInstructionWidenOrShorten *)instruction);
             break;

@@ -0,0 +1,882 @@
+pub const enum3 = []u64 {
+    0x4e2e2785c3a2a20b,
+    0x240a28877a09a4e1,
+    0x728fca36c06cf106,
+    0x1016b100e18e5c17,
+    0x3159190e30e46c1d,
+    0x64312a13daa46fe4,
+    0x7c41926c7a7122ba,
+    0x08667a3c8dc4bc9c,
+    0x18dde996371c6060,
+    0x297c2c31a31998ae,
+    0x368b870de5d93270,
+    0x57d561def4a9ee32,
+    0x6d275d226331d03a,
+    0x76703d7cb98edc59,
+    0x7ec490abad057752,
+    0x037be9d5a60850b5,
+    0x0c63165633977bca,
+    0x14a048cb468bc209,
+    0x20dc29bc6879dfcd,
+    0x2643dc6227de9148,
+    0x2d64f14348a4c5db,
+    0x341eef5e1f90ac35,
+    0x4931159a8bd8a240,
+    0x503ca9bade45b94a,
+    0x5c1af5b5378aa2e5,
+    0x6b4ef9beaa7aa584,
+    0x6ef1c382c3819a0a,
+    0x754fe46e378bf133,
+    0x7ace779fddf21622,
+    0x7df22815078cb97b,
+    0x7f33c8eeb77b8d05,
+    0x011b7aa3d73f6658,
+    0x06ceb7f2c53db97f,
+    0x0b8f3d82e9356287,
+    0x0e304273b18918b0,
+    0x139fb24e492936f6,
+    0x176090684f5fe997,
+    0x1e3035e7b5183922,
+    0x220ce77c2b3328fc,
+    0x246441ed79830182,
+    0x279b5cd8bbdd8770,
+    0x2cc7c3fba45c1272,
+    0x3081eab25ad0fcf7,
+    0x329f5a18504dfaac,
+    0x347eef5e1f90ac35,
+    0x3a978cfcab31064c,
+    0x4baa32ac316fb3ab,
+    0x4eb9a2c2a34ac2f9,
+    0x522f6a5025e71a61,
+    0x5935ede8cce30845,
+    0x5f9aeac2d1ea2695,
+    0x6820ee7811241ad3,
+    0x6c06c9e14b7c22c3,
+    0x6e5a2fbffdb7580c,
+    0x71160cf8f38b0465,
+    0x738a37935f3b71c9,
+    0x756fe46e378bf133,
+    0x7856d2aa2fc5f2b5,
+    0x7bd3b063946e10ae,
+    0x7d8220e1772428d7,
+    0x7e222815078cb97b,
+    0x7ef5bc471d5456c7,
+    0x7fb82baa4ae611dc,
+    0x00bb7aa3d73f6658,
+    0x0190a0f3c55062c5,
+    0x05898e3445512a6e,
+    0x07bfe89cf1bd76ac,
+    0x08dfa7ebe304ee3e,
+    0x0c43165633977bca,
+    0x0e104273b18918b0,
+    0x0fd6ba8608faa6a9,
+    0x10b4139a6b17b224,
+    0x1466cc4fc92a0fa6,
+    0x162ba6008389068a,
+    0x1804116d591ef1fb,
+    0x1c513770474911bd,
+    0x1e7035e7b5183923,
+    0x2114dab846e19e25,
+    0x222ce77c2b3328fc,
+    0x244441ed79830182,
+    0x249b23b50fc204db,
+    0x278aacfcb88c92d6,
+    0x289d52af46e5fa6a,
+    0x2bdec922478c0421,
+    0x2d44f14348a4c5dc,
+    0x2f0c1249e96b6d8d,
+    0x30addc7e975c5045,
+    0x322aedaa0fc32ac8,
+    0x33deef5e1f90ac34,
+    0x343eef5e1f90ac35,
+    0x35ef1de1f7f14439,
+    0x3854faba79ea92ec,
+    0x47f52d02c7e14af7,
+    0x4a6bb6979ae39c49,
+    0x4c85564fb098c955,
+    0x4e80fde34c996086,
+    0x4ed9a2c2a34ac2f9,
+    0x51a3274280201a89,
+    0x574fe0403124a00e,
+    0x581561def4a9ee31,
+    0x5b55ed1f039cebff,
+    0x5e2780695036a679,
+    0x624be064a3fb2725,
+    0x674dcfee6690ffc6,
+    0x6a6cc08102f0da5b,
+    0x6be6c9e14b7c22c4,
+    0x6ce75d226331d03a,
+    0x6d5b9445072f4374,
+    0x6e927edd0dbb8c09,
+    0x71060cf8f38b0465,
+    0x71b1d7cb7eae05d9,
+    0x72fba10d818fdafd,
+    0x739a37935f3b71c9,
+    0x755fe46e378bf133,
+    0x76603d7cb98edc59,
+    0x78447e17e7814ce7,
+    0x799d696737fe68c7,
+    0x7ade779fddf21622,
+    0x7c1c283ffc61c87d,
+    0x7d1a85c6f7fba05d,
+    0x7da220e1772428d7,
+    0x7e022815078cb97b,
+    0x7e9a9b45a91f1700,
+    0x7ee3c8eeb77b8d05,
+    0x7f13c8eeb77b8d05,
+    0x7f6594223f5654bf,
+    0x7fd82baa4ae611dc,
+    0x002d243f646eaf51,
+    0x00f5d15b26b80e30,
+    0x0180a0f3c55062c5,
+    0x01f393b456eef178,
+    0x05798e3445512a6e,
+    0x06afdadafcacdf85,
+    0x06e8b03fd6894b66,
+    0x07cfe89cf1bd76ac,
+    0x08ac25584881552a,
+    0x097822507db6a8fd,
+    0x0c27b35936d56e28,
+    0x0c53165633977bca,
+    0x0c8e9eddbbb259b4,
+    0x0e204273b18918b0,
+    0x0f1d16d6d4b89689,
+    0x0fe6ba8608faa6a9,
+    0x105f48347c60a1be,
+    0x13627383c5456c5e,
+    0x13f93bb1e72a2033,
+    0x148048cb468bc208,
+    0x1514c0b3a63c1444,
+    0x175090684f5fe997,
+    0x17e4116d591ef1fb,
+    0x18cde996371c6060,
+    0x19aa2cf604c30d3f,
+    0x1d2b1ad9101b1bfd,
+    0x1e5035e7b5183923,
+    0x1fe5a79c4e71d028,
+    0x20ec29bc6879dfcd,
+    0x218ce77c2b3328fb,
+    0x221ce77c2b3328fc,
+    0x233f346f9ed36b89,
+    0x243441ed79830182,
+    0x245441ed79830182,
+    0x247441ed79830182,
+    0x2541e4ee41180c0a,
+    0x277aacfcb88c92d6,
+    0x279aacfcb88c92d6,
+    0x27cbb4c6bd8601bd,
+    0x28c04a616046e074,
+    0x2a4eeff57768f88c,
+    0x2c2379f099a86227,
+    0x2d04f14348a4c5db,
+    0x2d54f14348a4c5dc,
+    0x2d6a8c931c19b77a,
+    0x2fa387cf9cb4ad4e,
+    0x308ddc7e975c5046,
+    0x3149190e30e46c1d,
+    0x318d2ec75df6ba2a,
+    0x32548050091c3c24,
+    0x33beef5e1f90ac34,
+    0x33feef5e1f90ac35,
+    0x342eef5e1f90ac35,
+    0x345eef5e1f90ac35,
+    0x35108621c4199208,
+    0x366b870de5d93270,
+    0x375b20c2f4f8d4a0,
+    0x3864faba79ea92ec,
+    0x3aa78cfcab31064c,
+    0x4919d9577de925d5,
+    0x49ccadd6dd730c96,
+    0x4b9a32ac316fb3ab,
+    0x4bba32ac316fb3ab,
+    0x4cff20b1a0d7f626,
+    0x4e3e2785c3a2a20b,
+    0x4ea9a2c2a34ac2f9,
+    0x4ec9a2c2a34ac2f9,
+    0x4f28750ea732fdae,
+    0x513843e10734fa57,
+    0x51e71760b3c0bc13,
+    0x55693ba3249a8511,
+    0x57763ae2caed4528,
+    0x57f561def4a9ee32,
+    0x584561def4a9ee31,
+    0x5b45ed1f039cebfe,
+    0x5bfaf5b5378aa2e5,
+    0x5c6cf45d333da323,
+    0x5e64ec8fd70420c7,
+    0x6009813653f62db7,
+    0x64112a13daa46fe4,
+    0x672dcfee6690ffc6,
+    0x677a77581053543b,
+    0x699873e3758bc6b3,
+    0x6b3ef9beaa7aa584,
+    0x6b7b86d8c3df7cd1,
+    0x6bf6c9e14b7c22c3,
+    0x6c16c9e14b7c22c3,
+    0x6d075d226331d03a,
+    0x6d5a3bdac4f00f33,
+    0x6e4a2fbffdb7580c,
+    0x6e927edd0dbb8c08,
+    0x6ee1c382c3819a0a,
+    0x70f60cf8f38b0465,
+    0x7114390c68b888ce,
+    0x714fb4840532a9e5,
+    0x727fca36c06cf106,
+    0x72eba10d818fdafd,
+    0x737a37935f3b71c9,
+    0x73972852443155ae,
+    0x754fe46e378bf132,
+    0x755fe46e378bf132,
+    0x756fe46e378bf132,
+    0x76603d7cb98edc58,
+    0x76703d7cb98edc58,
+    0x782f7c6a9ad432a1,
+    0x78547e17e7814ce7,
+    0x7964066d88c7cab8,
+    0x7ace779fddf21621,
+    0x7ade779fddf21621,
+    0x7bc3b063946e10ae,
+    0x7c0c283ffc61c87d,
+    0x7c31926c7a7122ba,
+    0x7d0a85c6f7fba05d,
+    0x7d52a5daf9226f04,
+    0x7d9220e1772428d7,
+    0x7db220e1772428d7,
+    0x7dfe5aceedf1c1f1,
+    0x7e122815078cb97b,
+    0x7e8a9b45a91f1700,
+    0x7eb6202598194bee,
+    0x7ec6202598194bee,
+    0x7ef3c8eeb77b8d05,
+    0x7f03c8eeb77b8d05,
+    0x7f23c8eeb77b8d05,
+    0x7f5594223f5654bf,
+    0x7f9914e03c9260ee,
+    0x7fc82baa4ae611dc,
+    0x7fefffffffffffff,
+    0x001d243f646eaf51,
+    0x00ab7aa3d73f6658,
+    0x00cb7aa3d73f6658,
+    0x010b7aa3d73f6658,
+    0x012b7aa3d73f6658,
+    0x0180a0f3c55062c6,
+    0x0190a0f3c55062c6,
+    0x03719f08ccdccfe5,
+    0x03dc25ba6a45de02,
+    0x05798e3445512a6f,
+    0x05898e3445512a6f,
+    0x06bfdadafcacdf85,
+    0x06cfdadafcacdf85,
+    0x06f8b03fd6894b66,
+    0x07c1707c02068785,
+    0x08567a3c8dc4bc9c,
+    0x089c25584881552a,
+    0x08dfa7ebe304ee3d,
+    0x096822507db6a8fd,
+    0x09e41934d77659be,
+    0x0c27b35936d56e27,
+    0x0c43165633977bc9,
+    0x0c53165633977bc9,
+    0x0c63165633977bc9,
+    0x0c7e9eddbbb259b4,
+    0x0c9e9eddbbb259b4,
+    0x0e104273b18918b1,
+    0x0e204273b18918b1,
+    0x0e304273b18918b1,
+    0x0fd6ba8608faa6a8,
+    0x0fe6ba8608faa6a8,
+    0x1006b100e18e5c17,
+    0x104f48347c60a1be,
+    0x10a4139a6b17b224,
+    0x12cb91d317c8ebe9,
+    0x138fb24e492936f6,
+    0x13afb24e492936f6,
+    0x14093bb1e72a2033,
+    0x1476cc4fc92a0fa6,
+    0x149048cb468bc209,
+    0x1504c0b3a63c1444,
+    0x161ba6008389068a,
+    0x168cfab1a09b49c4,
+    0x175090684f5fe998,
+    0x176090684f5fe998,
+    0x17f4116d591ef1fb,
+    0x18a710b7a2ef18b7,
+    0x18d99fccca44882a,
+    0x199a2cf604c30d3f,
+    0x1b5ebddc6593c857,
+    0x1d1b1ad9101b1bfd,
+    0x1d3b1ad9101b1bfd,
+    0x1e4035e7b5183923,
+    0x1e6035e7b5183923,
+    0x1fd5a79c4e71d028,
+    0x20cc29bc6879dfcd,
+    0x20e8823a57adbef8,
+    0x2104dab846e19e25,
+    0x2124dab846e19e25,
+    0x220ce77c2b3328fb,
+    0x221ce77c2b3328fb,
+    0x222ce77c2b3328fb,
+    0x229197b290631476,
+    0x240a28877a09a4e0,
+    0x243441ed79830181,
+    0x244441ed79830181,
+    0x245441ed79830181,
+    0x246441ed79830181,
+    0x247441ed79830181,
+    0x248b23b50fc204db,
+    0x24ab23b50fc204db,
+    0x2633dc6227de9148,
+    0x2653dc6227de9148,
+    0x277aacfcb88c92d7,
+    0x278aacfcb88c92d7,
+    0x279aacfcb88c92d7,
+    0x27bbb4c6bd8601bd,
+    0x289d52af46e5fa69,
+    0x28b04a616046e074,
+    0x28d04a616046e074,
+    0x2a3eeff57768f88c,
+    0x2b8e3a0aeed7be19,
+    0x2beec922478c0421,
+    0x2cc7c3fba45c1271,
+    0x2cf4f14348a4c5db,
+    0x2d44f14348a4c5db,
+    0x2d54f14348a4c5db,
+    0x2d5a8c931c19b77a,
+    0x2d64f14348a4c5dc,
+    0x2efc1249e96b6d8d,
+    0x2f0f6b23cfe98807,
+    0x2fe91b9de4d5cf31,
+    0x308ddc7e975c5045,
+    0x309ddc7e975c5045,
+    0x30bddc7e975c5045,
+    0x3150ed9bd6bfd003,
+    0x317d2ec75df6ba2a,
+    0x321aedaa0fc32ac8,
+    0x32448050091c3c24,
+    0x328f5a18504dfaac,
+    0x3336dca59d035820,
+    0x33ceef5e1f90ac34,
+    0x33eeef5e1f90ac35,
+    0x340eef5e1f90ac35,
+    0x34228f9edfbd3420,
+    0x34328f9edfbd3420,
+    0x344eef5e1f90ac35,
+    0x346eef5e1f90ac35,
+    0x35008621c4199208,
+    0x35e0ac2e7f90b8a3,
+    0x361dde4a4ab13e09,
+    0x367b870de5d93270,
+    0x375b20c2f4f8d49f,
+    0x37f25d342b1e33e5,
+    0x3854faba79ea92ed,
+    0x3864faba79ea92ed,
+    0x3a978cfcab31064d,
+    0x3aa78cfcab31064d,
+    0x490cd230a7ff47c3,
+    0x4929d9577de925d5,
+    0x4939d9577de925d5,
+    0x49dcadd6dd730c96,
+    0x4a7bb6979ae39c49,
+    0x4b9a32ac316fb3ac,
+    0x4baa32ac316fb3ac,
+    0x4bba32ac316fb3ac,
+    0x4cef20b1a0d7f626,
+    0x4e2e2785c3a2a20a,
+    0x4e3e2785c3a2a20a,
+    0x4e6454b1aef62c8d,
+    0x4e90fde34c996086,
+    0x4ea9a2c2a34ac2fa,
+    0x4eb9a2c2a34ac2fa,
+    0x4ec9a2c2a34ac2fa,
+    0x4ed9a2c2a34ac2fa,
+    0x4f38750ea732fdae,
+    0x504ca9bade45b94a,
+    0x514843e10734fa57,
+    0x51b3274280201a89,
+    0x521f6a5025e71a61,
+    0x52c6a47d4e7ec633,
+    0x55793ba3249a8511,
+    0x575fe0403124a00e,
+    0x57863ae2caed4528,
+    0x57e561def4a9ee32,
+    0x580561def4a9ee31,
+    0x582561def4a9ee31,
+    0x585561def4a9ee31,
+    0x59d0dd8f2788d699,
+    0x5b55ed1f039cebfe,
+    0x5beaf5b5378aa2e5,
+    0x5c0af5b5378aa2e5,
+    0x5c4ef3052ef0a361,
+    0x5e1780695036a679,
+    0x5e54ec8fd70420c7,
+    0x5e6b5e2f86026f05,
+    0x5faaeac2d1ea2695,
+    0x611260322d04d50b,
+    0x625be064a3fb2725,
+    0x64212a13daa46fe4,
+    0x671dcfee6690ffc6,
+    0x673dcfee6690ffc6,
+    0x675dcfee6690ffc6,
+    0x678a77581053543b,
+    0x682d3683fa3d1ee0,
+    0x699cb490951e8515,
+    0x6b3ef9beaa7aa583,
+    0x6b4ef9beaa7aa583,
+    0x6b7896beb0c66eb9,
+    0x6bdf20938e7414bb,
+    0x6bef20938e7414bb,
+    0x6bf6c9e14b7c22c4,
+    0x6c06c9e14b7c22c4,
+    0x6c16c9e14b7c22c4,
+    0x6cf75d226331d03a,
+    0x6d175d226331d03a,
+    0x6d4b9445072f4374,
+};
+
+const Slab = struct {
+    str: []const u8,
+    exp: i32,
+};
+
+fn slab(str: []const u8, exp: i32) -> Slab {
+    Slab {
+        .str = str,
+        .exp = exp,
+    }
+}
+
+pub const enum3_data = []Slab {
+    slab("40648030339495312", 69),
+    slab("4498645355592131", -134),
+    slab("678321594594593", 244),
+    slab("36539702510912277", -230),
+    slab("56819570380646536", -70),
+    slab("42452693975546964", 175),
+    slab("34248868699178663", 291),
+    slab("34037810581283983", -267),
+    slab("67135881167178176", -188),
+    slab("74973710847373845", -108),
+    slab("60272377639347644", -45),
+    slab("1316415380484425", 116),
+    slab("64433314612521525", 218),
+    slab("31961502891542243", 263),
+    slab("4407140524515149", 303),
+    slab("69928982131052126", -291),
+    slab("5331838923808276", -248),
+    slab("24766435002945523", -208),
+    slab("21509066976048781", -149),
+    slab("2347200170470694", -123),
+    slab("51404180294474556", -89),
+    slab("12320586499023201", -56),
+    slab("38099461575161174", 45),
+    slab("3318949537676913", 79),
+    slab("48988560059074597", 136),
+    slab("7955843973866726", 209),
+    slab("2630089515909384", 227),
+    slab("11971601492124911", 258),
+    slab("35394816534699092", 284),
+    slab("47497368114750945", 299),
+    slab("54271187548763685", 305),
+    slab("2504414972009504", -302),
+    slab("69316187906522606", -275),
+    slab("53263359599109627", -252),
+    slab("24384437085962037", -239),
+    slab("3677854139813342", -213),
+    slab("44318030915155535", -195),
+    slab("28150140033551147", -162),
+    slab("1157373742186464", -143),
+    slab("2229658838863212", -132),
+    slab("67817280930489786", -117),
+    slab("56966478488538934", -92),
+    slab("49514357246452655", -74),
+    slab("74426102121433776", -64),
+    slab("78851753593748485", -55),
+    slab("19024128529074359", -25),
+    slab("32118580932839778", 57),
+    slab("17693166778887419", 72),
+    slab("78117757194253536", 88),
+    slab("56627018760181905", 122),
+    slab("35243988108650928", 153),
+    slab("38624526316654214", 194),
+    slab("2397422026462446", 213),
+    slab("37862966954556723", 224),
+    slab("56089100059334965", 237),
+    slab("3666156212014994", 249),
+    slab("47886405968499643", 258),
+    slab("48228872759189434", 272),
+    slab("29980574575739863", 289),
+    slab("37049827284413546", 297),
+    slab("37997894491800756", 300),
+    slab("37263572163337027", 304),
+    slab("16973149506391291", 308),
+    slab("391314839376485", -304),
+    slab("38797447671091856", -300),
+    slab("54994366114768736", -281),
+    slab("23593494977819109", -270),
+    slab("61359116592542813", -265),
+    slab("1332959730952069", -248),
+    slab("6096109271490509", -240),
+    slab("22874741188249992", -231),
+    slab("33104948806015703", -227),
+    slab("21670630627577332", -209),
+    slab("70547825868713855", -201),
+    slab("54981742371928845", -192),
+    slab("27843818440071113", -171),
+    slab("4504022405368184", -161),
+    slab("2548351460621656", -148),
+    slab("4629494968745856", -143),
+    slab("557414709715803", -133),
+    slab("23897004381644022", -131),
+    slab("33057350728075958", -117),
+    slab("47628822744182433", -112),
+    slab("22520091703825729", -96),
+    slab("1285104507361864", -89),
+    slab("46239793787746783", -81),
+    slab("330095714976351", -73),
+    slab("4994144928421182", -66),
+    slab("77003665618895", -58),
+    slab("49282345996092803", -56),
+    slab("66534156679273626", -48),
+    slab("24661175471861008", -36),
+    slab("45035996273704964", 39),
+    slab("32402369146794532", 51),
+    slab("42859354584576066", 61),
+    slab("1465909318208761", 71),
+    slab("70772667115549675", 72),
+    slab("18604316837693468", 86),
+    slab("38329392744333992", 113),
+    slab("21062646087750798", 117),
+    slab("972708181182949", 132),
+    slab("36683053719290777", 146),
+    slab("32106017483029628", 166),
+    slab("41508952543121158", 190),
+    slab("45072812455233127", 205),
+    slab("59935550661561155", 212),
+    slab("40270821632825953", 217),
+    slab("60846862848160256", 219),
+    slab("42788225889846894", 225),
+    slab("28044550029667482", 237),
+    slab("46475406389115295", 240),
+    slab("7546114860200514", 246),
+    slab("7332312424029988", 249),
+    slab("23943202984249821", 258),
+    slab("15980751445771122", 263),
+    slab("21652206566352648", 272),
+    slab("65171333649148234", 278),
+    slab("70789633069398184", 284),
+    slab("68600253110025576", 290),
+    slab("4234784709771466", 295),
+    slab("14819930913765419", 298),
+    slab("9499473622950189", 299),
+    slab("71272819274635585", 302),
+    slab("16959746108988652", 304),
+    slab("13567796887190921", 305),
+    slab("4735325513114182", 306),
+    slab("67892598025565165", 308),
+    slab("81052743999542975", -307),
+    slab("4971131903427841", -303),
+    slab("19398723835545928", -300),
+    slab("29232758945460627", -298),
+    slab("27497183057384368", -281),
+    slab("17970091719480621", -275),
+    slab("22283747288943228", -274),
+    slab("47186989955638217", -270),
+    slab("6819439187504402", -266),
+    slab("47902021250710456", -262),
+    slab("41378294570975613", -249),
+    slab("2665919461904138", -248),
+    slab("3421423777071132", -247),
+    slab("12192218542981019", -239),
+    slab("7147520638007367", -235),
+    slab("45749482376499984", -231),
+    slab("80596937390013985", -229),
+    slab("26761990828289327", -214),
+    slab("18738512510673039", -211),
+    slab("619160875073638", -209),
+    slab("403997300048931", -206),
+    slab("22159015457577768", -195),
+    slab("13745435592982211", -192),
+    slab("33567940583589088", -188),
+    slab("4812711195250522", -184),
+    slab("3591036630219558", -167),
+    slab("1126005601342046", -161),
+    slab("5047135806497922", -154),
+    slab("43018133952097563", -149),
+    slab("45209911804158747", -146),
+    slab("2314747484372928", -143),
+    slab("65509428048152994", -138),
+    slab("2787073548579015", -133),
+    slab("1114829419431606", -132),
+    slab("4459317677726424", -132),
+    slab("32269008655522087", -128),
+    slab("16528675364037979", -117),
+    slab("66114701456151916", -117),
+    slab("54934856534126976", -116),
+    slab("21168365664081082", -111),
+    slab("67445733463759384", -104),
+    slab("45590931008842566", -95),
+    slab("8031903171011649", -91),
+    slab("2570209014723728", -89),
+    slab("6516605505584466", -89),
+    slab("32943123175907307", -78),
+    slab("82523928744087755", -74),
+    slab("28409785190323268", -70),
+    slab("52853886779813977", -69),
+    slab("30417302377115577", -65),
+    slab("1925091640472375", -58),
+    slab("30801466247558002", -57),
+    slab("24641172998046401", -56),
+    slab("19712938398437121", -55),
+    slab("43129529027318865", -52),
+    slab("15068094409836911", -45),
+    slab("48658418478920193", -41),
+    slab("49322350943722016", -36),
+    slab("38048257058148717", -25),
+    slab("14411294198511291", 45),
+    slab("32745697577386472", 48),
+    slab("16059290466419889", 57),
+    slab("64237161865679556", 57),
+    slab("8003248329710242", 63),
+    slab("81296060678990625", 69),
+    slab("8846583389443709", 71),
+    slab("35386333557774838", 72),
+    slab("21606114462319112", 74),
+    slab("18413733104063271", 84),
+    slab("35887030159858487", 87),
+    slab("2825769263311679", 104),
+    slab("2138446062528161", 114),
+    slab("52656615219377", 116),
+    slab("16850116870200639", 118),
+    slab("48635409059147446", 132),
+    slab("12247140014768649", 136),
+    slab("16836228873919609", 138),
+    slab("5225574770881846", 147),
+    slab("42745323906998127", 155),
+    slab("10613173493886741", 175),
+    slab("10377238135780289", 190),
+    slab("29480080280199528", 191),
+    slab("4679330956996797", 201),
+    slab("3977921986933363", 209),
+    slab("56560320317673966", 210),
+    slab("1198711013231223", 213),
+    slab("4794844052924892", 213),
+    slab("16108328653130381", 218),
+    slab("57878622568856074", 219),
+    slab("18931483477278361", 224),
+    slab("4278822588984689", 225),
+    slab("1315044757954692", 227),
+    slab("14022275014833741", 237),
+    slab("5143975308105889", 237),
+    slab("64517311884236306", 238),
+    slab("3391607972972965", 244),
+    slab("3773057430100257", 246),
+    slab("1833078106007497", 249),
+    slab("64766168833734675", 249),
+    slab("1197160149212491", 258),
+    slab("2394320298424982", 258),
+    slab("4788640596849964", 258),
+    slab("1598075144577112", 263),
+    slab("3196150289154224", 263),
+    slab("83169412421960475", 271),
+    slab("43304413132705296", 272),
+    slab("5546524276967009", 277),
+    slab("3539481653469909", 284),
+    slab("7078963306939818", 284),
+    slab("14990287287869931", 289),
+    slab("34300126555012788", 290),
+    slab("17124434349589332", 291),
+    slab("2117392354885733", 295),
+    slab("47639264836707725", 296),
+    slab("7409965456882709", 297),
+    slab("29639861827530837", 298),
+    slab("79407577493590275", 299),
+    slab("18998947245900378", 300),
+    slab("35636409637317792", 302),
+    slab("23707742595255608", 303),
+    slab("47415485190511216", 303),
+    slab("33919492217977303", 304),
+    slab("6783898443595461", 304),
+    slab("27135593774381842", 305),
+    slab("2367662756557091", 306),
+    slab("44032152438472327", 307),
+    slab("33946299012782582", 308),
+    slab("17976931348623157", 309),
+    slab("40526371999771488", -307),
+    slab("1956574196882425", -304),
+    slab("78262967875297", -304),
+    slab("1252207486004752", -302),
+    slab("5008829944019008", -302),
+    slab("1939872383554593", -300),
+    slab("3879744767109186", -300),
+    slab("44144884605471774", -291),
+    slab("45129663866844427", -289),
+    slab("2749718305738437", -281),
+    slab("5499436611476874", -281),
+    slab("35940183438961242", -275),
+    slab("71880366877922484", -275),
+    slab("44567494577886457", -274),
+    slab("25789638850173173", -270),
+    slab("17018905290641991", -267),
+    slab("3409719593752201", -266),
+    slab("6135911659254281", -265),
+    slab("23951010625355228", -262),
+    slab("51061856989121905", -260),
+    slab("4137829457097561", -249),
+    slab("13329597309520689", -248),
+    slab("26659194619041378", -248),
+    slab("53318389238082755", -248),
+    slab("1710711888535566", -247),
+    slab("6842847554142264", -247),
+    slab("609610927149051", -240),
+    slab("1219221854298102", -239),
+    slab("2438443708596204", -239),
+    slab("2287474118824999", -231),
+    slab("4574948237649998", -231),
+    slab("18269851255456139", -230),
+    slab("40298468695006992", -229),
+    slab("16552474403007851", -227),
+    slab("39050270537318193", -217),
+    slab("1838927069906671", -213),
+    slab("7355708279626684", -213),
+    slab("37477025021346077", -211),
+    slab("43341261255154663", -209),
+    slab("12383217501472761", -208),
+    slab("2019986500244655", -206),
+    slab("35273912934356928", -201),
+    slab("47323883490786093", -199),
+    slab("2215901545757777", -195),
+    slab("4431803091515554", -195),
+    slab("27490871185964422", -192),
+    slab("64710073234908765", -189),
+    slab("57511323531737074", -188),
+    slab("2406355597625261", -184),
+    slab("75862936714499446", -176),
+    slab("1795518315109779", -167),
+    slab("7182073260439116", -167),
+    slab("563002800671023", -162),
+    slab("2252011202684092", -161),
+    slab("2523567903248961", -154),
+    slab("10754533488024391", -149),
+    slab("37436263604934127", -149),
+    slab("1274175730310828", -148),
+    slab("5096702921243312", -148),
+    slab("11573737421864639", -143),
+    slab("23147474843729279", -143),
+    slab("46294949687458557", -143),
+    slab("36067106647774144", -141),
+    slab("44986453555921307", -134),
+    slab("27870735485790148", -133),
+    slab("55741470971580295", -133),
+    slab("11148294194316059", -132),
+    slab("22296588388632118", -132),
+    slab("44593176777264236", -132),
+    slab("11948502190822011", -131),
+    slab("47794008763288043", -131),
+    slab("1173600085235347", -123),
+    slab("4694400340941388", -123),
+    slab("1652867536403798", -117),
+    slab("3305735072807596", -117),
+    slab("6611470145615192", -117),
+    slab("27467428267063488", -116),
+    slab("4762882274418243", -112),
+    slab("10584182832040541", -111),
+    slab("42336731328162165", -111),
+    slab("33722866731879692", -104),
+    slab("69097540994131414", -98),
+    slab("45040183407651457", -96),
+    slab("5696647848853893", -92),
+    slab("40159515855058247", -91),
+    slab("12851045073618639", -89),
+    slab("25702090147237278", -89),
+    slab("3258302752792233", -89),
+    slab("5140418029447456", -89),
+    slab("23119896893873391", -81),
+    slab("51753157237874753", -81),
+    slab("67761208324172855", -77),
+    slab("8252392874408775", -74),
+    slab("1650478574881755", -73),
+    slab("660191429952702", -73),
+    slab("3832399419240467", -70),
+    slab("26426943389906988", -69),
+    slab("2497072464210591", -66),
+    slab("15208651188557789", -65),
+    slab("37213051060716888", -64),
+    slab("55574205388093594", -61),
+    slab("385018328094475", -58),
+    slab("15400733123779001", -57),
+    slab("61602932495116004", -57),
+    slab("14784703798827841", -56),
+    slab("29569407597655683", -56),
+    slab("9856469199218561", -56),
+    slab("39425876796874242", -55),
+    slab("21564764513659432", -52),
+    slab("35649516398744314", -48),
+    slab("51091836539008967", -47),
+    slab("30136188819673822", -45),
+    slab("4865841847892019", -41),
+    slab("33729482964455627", -38),
+    slab("2466117547186101", -36),
+    slab("4932235094372202", -36),
+    slab("1902412852907436", -25),
+    slab("3804825705814872", -25),
+    slab("80341375308088225", 44),
+    slab("28822588397022582", 45),
+    slab("57645176794045164", 45),
+    slab("65491395154772944", 48),
+    slab("64804738293589064", 51),
+    slab("1605929046641989", 57),
+    slab("3211858093283978", 57),
+    slab("6423716186567956", 57),
+    slab("4001624164855121", 63),
+    slab("4064803033949531", 69),
+    slab("8129606067899062", 69),
+    slab("4384946084578497", 70),
+    slab("2931818636417522", 71),
+    slab("884658338944371", 71),
+    slab("1769316677888742", 72),
+    slab("3538633355777484", 72),
+    slab("7077266711554968", 72),
+    slab("43212228924638223", 74),
+    slab("6637899075353826", 79),
+    slab("36827466208126543", 84),
+    slab("37208633675386937", 86),
+    slab("39058878597126768", 88),
+    slab("57654578150150385", 91),
+    slab("5651538526623358", 104),
+    slab("76658785488667984", 113),
+    slab("4276892125056322", 114),
+    slab("263283076096885", 116),
+    slab("10531323043875399", 117),
+    slab("42125292175501597", 117),
+    slab("33700233740401277", 118),
+    slab("44596066840334405", 125),
+    slab("9727081811829489", 132),
+    slab("61235700073843246", 135),
+    slab("24494280029537298", 136),
+    slab("4499029632233837", 137),
+    slab("18341526859645389", 146),
+    slab("2612787385440923", 147),
+    slab("6834859331393543", 147),
+    slab("70487976217301855", 153),
+    slab("40366692112133834", 160),
+    slab("64212034966059256", 166),
+    slab("21226346987773482", 175),
+    slab("51886190678901447", 189),
+    slab("20754476271560579", 190),
+    slab("83017905086242315", 190),
+    slab("58960160560399056", 191),
+    slab("66641177824100826", 194),
+    slab("5493127645170153", 201),
+    slab("39779219869333628", 209),
+    slab("79558439738667255", 209),
+    slab("50523702331566894", 210),
+    slab("40933393326155808", 212),
+    slab("81866786652311615", 212),
+    slab("11987110132312231", 213),
+    slab("23974220264624462", 213),
+    slab("47948440529248924", 213),
+    slab("8054164326565191", 217),
+    slab("32216657306260762", 218),
+    slab("30423431424080128", 219),
+};
+

@@ -0,0 +1,651 @@
+const enum3 = @import("enum3.zig").enum3;
+const enum3_data = @import("enum3.zig").enum3_data;
+const lookup_table = @import("lookup.zig").lookup_table;
+const HP = @import("lookup.zig").HP;
+const math = @import("../../math/index.zig");
+const mem = @import("../../mem.zig");
+const assert = @import("../../debug.zig").assert;
+
+pub const FloatDecimal = struct {
+    digits: []u8,
+    exp: i32,
+};
+
+const u128 = @IntType(false, 128);
+
+/// Corrected Errol3 double to ASCII conversion.
+pub fn errol3(value: f64, buffer: []u8) -> FloatDecimal {
+    const bits = @bitCast(u64, value);
+    const i = tableLowerBound(bits);
+    if (i < enum3.len and enum3[i] == bits) {
+        const data = enum3_data[i];
+        const digits = buffer[0..data.str.len];
+        mem.copy(u8, digits, data.str);
+        return FloatDecimal {
+            .digits = digits,
+            .exp = data.exp,
+        };
+    }
+
+    return errol3u(value, buffer);
+}
+
+/// Uncorrected Errol3 double to ASCII conversion.
+fn errol3u(val: f64, buffer: []u8) -> FloatDecimal {
+    // check if in integer or fixed range
+
+    if (val >= 9.007199254740992e15 and val < 3.40282366920938e+38) {
+        return errolInt(val, buffer);
+    } else if (val >= 16.0 and val < 9.007199254740992e15) {
+        return errolFixed(val, buffer);
+    }
+
+    
+    // normalize the midpoint
+
+    var e: i32 = undefined;
+    _ = math.frexp(val, &e);
+    var exp = i16(math.floor(307 + f64(e) * 0.30103));
+    if (exp < 20) {
+        exp = 20;
+    } else if (usize(exp) >= lookup_table.len) {
+        exp = i16(lookup_table.len - 1);
+    }
+
+    var mid = lookup_table[usize(exp)];
+    mid = hpProd(mid, val);
+    const lten = lookup_table[usize(exp)].val;
+
+    exp -= 307;
+
+    var ten: f64 = 1.0;
+
+    while (mid.val > 10.0 or (mid.val == 10.0 and mid.off >= 0.0)) {
+        exp += 1;
+        hpDiv10(&mid);
+        ten /= 10.0;
+    }
+
+    while (mid.val < 1.0 or (mid.val == 1.0 and mid.off < 0.0)) {
+        exp -= 1;
+        hpMul10(&mid);
+        ten *= 10.0;
+    }
+
+    // compute boundaries
+    var high = HP {
+        .val = mid.val,
+        .off = mid.off + (fpnext(val) - val) * lten * ten / 2.0,
+    };
+    var low = HP {
+        .val = mid.val,
+        .off = mid.off + (fpprev(val) - val) * lten * ten / 2.0,
+    };
+
+    hpNormalize(&high);
+    hpNormalize(&low);
+
+    // normalized boundaries
+
+    while (high.val > 10.0 or (high.val == 10.0 and high.off >= 0.0)) {
+        exp += 1;
+        hpDiv10(&high);
+        hpDiv10(&low);
+    }
+
+    while (high.val < 1.0 or (high.val == 1.0 and high.off < 0.0)) {
+        exp -= 1;
+        hpMul10(&high);
+        hpMul10(&low);
+    }
+
+    // digit generation
+    var buf_index: usize = 0;
+    while (true) {
+        var hdig = u8(math.floor(high.val));
+        if ((high.val == f64(hdig)) and (high.off < 0))
+            hdig -= 1;
+
+        var ldig = u8(math.floor(low.val));
+        if ((low.val == f64(ldig)) and (low.off < 0))
+            ldig -= 1;
+
+        if (ldig != hdig)
+            break;
+
+        buffer[buf_index] = hdig + '0';
+        buf_index += 1;
+        high.val -= f64(hdig);
+        low.val -= f64(ldig);
+        hpMul10(&high);
+        hpMul10(&low);
+    }
+
+    const tmp = (high.val + low.val) / 2.0;
+    var mdig = u8(math.floor(tmp + 0.5));
+    if ((f64(mdig) - tmp) == 0.5 and (mdig & 0x1) != 0)
+        mdig -= 1;
+
+    buffer[buf_index] = mdig + '0';
+    buf_index += 1;
+
+    return FloatDecimal {
+        .digits = buffer[0..buf_index],
+        .exp = exp,
+    };
+}
+
+fn tableLowerBound(k: u64) -> usize {
+    var i = enum3.len;
+    var j: usize = 0;
+
+    while (j < enum3.len) {
+        if (enum3[j] < k) {
+            j = 2 * k + 2;
+        } else {
+            i = j;
+            j = 2 * j + 1;
+        }
+    }
+
+    return i;
+}
+
+/// Compute the product of an HP number and a double.
+///   @in: The HP number.
+///   @val: The double.
+///   &returns: The HP number.
+fn hpProd(in: &const HP, val: f64) -> HP {
+    var hi: f64 = undefined;
+    var lo: f64 = undefined;
+    split(in.val, &hi, &lo);
+
+    var hi2: f64 = undefined;
+    var lo2: f64 = undefined;
+    split(val, &hi2, &lo2);
+
+    const p = in.val * val;
+    const e = ((hi * hi2 - p) + lo * hi2 + hi * lo2) + lo * lo2;
+
+    return HP {
+        .val = p,
+        .off = in.off * val + e,
+    };
+}
+
+/// Split a double into two halves.
+///   @val: The double.
+///   @hi: The high bits.
+///   @lo: The low bits.
+fn split(val: f64, hi: &f64, lo: &f64) {
+    *hi = gethi(val);
+    *lo = val - *hi;
+}
+
+fn gethi(in: f64) {
+    const bits = @bitCast(u64, in);
+    const new_bits = bits & 0xFFFFFFFFF8000000;
+    return @bitCast(f64, new_bits);
+}
+
+/// Normalize the number by factoring in the error.
+///   @hp: The float pair.
+fn hpNormalize(hp: &HP) {
+    const val = hp.val;
+
+    hp.val += hp.off;
+    hp.off += val - hp.val;
+}
+
+/// Divide the high-precision number by ten.
+///   @hp: The high-precision number
+fn hpDiv10(hp: &HP) {
+    const val = hp.val;
+
+    hp.val /= 10.0;
+    hp.off /= 10.0;
+
+    val -= hp.val * 8.0;
+    val -= hp.val * 2.0;
+
+    hp.off += val / 10.0;
+
+    hpNormalize(hp);
+}
+
+/// Multiply the high-precision number by ten.
+///   @hp: The high-precision number
+fn hpMul10(hp: &HP) {
+    const val = hp.val;
+
+    hp.val *= 10.0;
+    hp.off *= 10.0;
+    
+    var off = hp.val;
+    off -= val * 8.0;
+    off -= val * 2.0;
+
+    hp.off -= off;
+
+    hpNormalize(hp);
+}
+
+
+/// Integer conversion algorithm, guaranteed correct, optimal, and best.
+///  @val: The val.
+///  @buf: The output buffer.
+///  &return: The exponent.
+fn errolInt(val: f64, buffer: []u8) -> FloatDecimal {
+    const pow19 = 1e19;
+
+    assert((val >= 9.007199254740992e15) and val < (3.40282366920938e38));
+
+    var mid = u128(val);
+    var low: u128 = mid - fpeint((fpnext(val) - val) / 2.0);
+    var high: u128 = mid + fpeint((val - fpprev(val)) / 2.0);
+
+    if (@bitCast(u64, val) & 0x1 != 0) { 
+        high -= 1;
+    } else {
+        low -= 1;
+    }
+
+    const l64 = u64(low % pow19);
+    const lf = u64((low / pow19) % pow19);
+
+    const h64 = u64(high % pow19);
+    const hf = u64((high / pow19) % pow19);
+
+    if (lf != hf) {
+        l64 = lf;
+        h64 = hf;
+        mid = mid / (pow19 / 10);
+    }
+
+    var mi: i32 = mismatch10(l64, h64);
+    var x: u64 = 1;
+    {
+        var i = i32(lf == hf);
+        while (i < mi) : (i += 1) {
+            x *= 10;
+        }
+    }
+    const m64: u64 = mid / x;
+
+    if (lf != hf)
+        mi += 19;
+
+    var buf_index = u64toa(m64, buffer) - 1;
+
+    if (mi != 0) {
+        buffer[buf_index - 1] += (buffer[buf_index] >= '5');
+    } else {
+        buf_index += 1;
+    }
+
+    return FloatDecimal {
+        .digits = buffer[0..buf_index],
+        .exp = buf_index + mi,
+    };
+}
+
+/// Fixed point conversion algorithm, guaranteed correct, optimal, and best.
+///  @val: The val.
+///  @buf: The output buffer.
+///  &return: The exponent.
+fn errolFixed(val: f64, buffer: []u8) -> FloatDecimal {
+    assert((val >= 16.0) and (val < 9.007199254740992e15));
+
+    const u = u64(val);
+    const n = f64(u);
+
+    var mid = val - n;
+    var lo = ((fpprev(val) - n) + mid) / 2.0;
+    var hi = ((fpnext(val) - n) + mid) / 2.0;
+
+    var buf_index = u64toa(u, buffer);
+    var exp: i32 = buf_index;
+    var j: i32 = exp;
+    buffer[j] = 0;
+
+    if (mid != 0.0) {
+        while (mid != 0.0) {
+            lo *= 10.0;
+            var ldig = i32(lo);
+            lo -= ldig;
+
+            mid *= 10.0;
+            var mdig = i32(mid);
+            mid -= mdig;
+
+            hi *= 10.0;
+            var hdig = i32(hi);
+            hi -= hdig;
+
+            buffer[j] = mdig + '0';
+            j += 1;
+
+            if(hdig != ldig or j > 50)
+                break;
+        }
+
+        if (mid > 0.5) {
+            buffer[j-1] += 1;
+        } else if ((mid == 0.5) and (buffer[j-1] & 0x1)) {
+            buffer[j-1] += 1;
+        }
+    } else {
+        while (buffer[j-1] == '0') {
+            buffer[j-1] = 0;
+            j -= 1;
+        }
+    }
+
+    buffer[j] = 0;
+
+    return FloatDecimal {
+        .digits = buffer[0..j],
+        .exp = exp,
+    };
+}
+
+fn fpnext(val: f64) -> f64 {
+    return @bitCast(f64, @bitCast(u64, val) + 1);
+}
+
+fn fpprev(val: f64) -> f64 {
+    return @bitCast(f64, @bitCast(u64, val) - 1);
+}
+
+pub const c_digits_lut = []u8 {
+    '0', '0', '0', '1', '0', '2', '0', '3', '0', '4', '0', '5', '0', '6',
+    '0', '7', '0', '8', '0', '9', '1', '0', '1', '1', '1', '2', '1', '3',
+    '1', '4', '1', '5', '1', '6', '1', '7', '1', '8', '1', '9', '2', '0',
+    '2', '1', '2', '2', '2', '3', '2', '4', '2', '5', '2', '6', '2', '7',
+    '2', '8', '2', '9', '3', '0', '3', '1', '3', '2', '3', '3', '3', '4',
+    '3', '5', '3', '6', '3', '7', '3', '8', '3', '9', '4', '0', '4', '1',
+    '4', '2', '4', '3', '4', '4', '4', '5', '4', '6', '4', '7', '4', '8',
+    '4', '9', '5', '0', '5', '1', '5', '2', '5', '3', '5', '4', '5', '5',
+    '5', '6', '5', '7', '5', '8', '5', '9', '6', '0', '6', '1', '6', '2',
+    '6', '3', '6', '4', '6', '5', '6', '6', '6', '7', '6', '8', '6', '9',
+    '7', '0', '7', '1', '7', '2', '7', '3', '7', '4', '7', '5', '7', '6',
+    '7', '7', '7', '8', '7', '9', '8', '0', '8', '1', '8', '2', '8', '3',
+    '8', '4', '8', '5', '8', '6', '8', '7', '8', '8', '8', '9', '9', '0',
+    '9', '1', '9', '2', '9', '3', '9', '4', '9', '5', '9', '6', '9', '7',
+    '9', '8', '9', '9',
+};
+
+fn u64toa(value: u64, buffer: []u8) -> usize {
+    const kTen8: u64 = 100000000;
+    const kTen9: u64 = kTen8 * 10;
+    const kTen10: u64 = kTen8 * 100;
+    const kTen11: u64 = kTen8 * 1000;
+    const kTen12: u64 = kTen8 * 10000;
+    const kTen13: u64 = kTen8 * 100000;
+    const kTen14: u64 = kTen8 * 1000000;
+    const kTen15: u64 = kTen8 * 10000000;
+    const kTen16: u64 = kTen8 * kTen8;
+
+    var buf_index: usize = 0;
+
+    if (value < kTen8) {
+        const v = u32(value);
+        if (v < 10000) {
+            const d1: u32 = (v / 100) << 1;
+            const d2: u32 = (v % 100) << 1;
+
+            if (v >= 1000) {
+                buffer[buf_index] = c_digits_lut[d1];
+                buf_index += 1;
+            }
+            if (v >= 100) {
+                buffer[buf_index] = c_digits_lut[d1 + 1];
+                buf_index += 1;
+            }
+            if (v >= 10) {
+                buffer[buf_index] = c_digits_lut[d2];
+                buf_index += 1;
+            }
+            buffer[buf_index] = c_digits_lut[d2 + 1];
+            buf_index += 1;
+        } else {
+            // value = bbbbcccc
+            const b: u32 = v / 10000;
+            const c: u32 = v % 10000;
+
+            const d1: u32 = (b / 100) << 1;
+            const d2: u32 = (b % 100) << 1;
+
+            const d3: u32 = (c / 100) << 1;
+            const d4: u32 = (c % 100) << 1;
+
+            if (value >= 10000000) {
+                buffer[buf_index] = c_digits_lut[d1];
+                buf_index += 1;
+            }
+            if (value >= 1000000) {
+                buffer[buf_index] = c_digits_lut[d1 + 1];
+                buf_index += 1;
+            }
+            if (value >= 100000) {
+                buffer[buf_index] = c_digits_lut[d2];
+                buf_index += 1;
+            }
+            buffer[buf_index] = c_digits_lut[d2 + 1];
+            buf_index += 1;
+
+            buffer[buf_index] = c_digits_lut[d3];
+            buf_index += 1;
+            buffer[buf_index] = c_digits_lut[d3 + 1];
+            buf_index += 1;
+            buffer[buf_index] = c_digits_lut[d4];
+            buf_index += 1;
+            buffer[buf_index] = c_digits_lut[d4 + 1];
+            buf_index += 1;
+        }
+    } else if (value < kTen16) {
+        const v0: u32 = (uint32_t)(value / kTen8);
+        const v1: u32 = (uint32_t)(value % kTen8);
+
+        const b0: u32 = v0 / 10000;
+        const c0: u32 = v0 % 10000;
+
+        const d1: u32 = (b0 / 100) << 1;
+        const d2: u32 = (b0 % 100) << 1;
+
+        const d3: u32 = (c0 / 100) << 1;
+        const d4: u32 = (c0 % 100) << 1;
+
+        const b1: u32 = v1 / 10000;
+        const c1: u32 = v1 % 10000;
+
+        const d5: u32 = (b1 / 100) << 1;
+        const d6: u32 = (b1 % 100) << 1;
+
+        const d7: u32 = (c1 / 100) << 1;
+        const d8: u32 = (c1 % 100) << 1;
+
+        if (value >= kTen15) {
+            buffer[buf_index] = c_digits_lut[d1];
+            buf_index += 1;
+        }
+        if (value >= kTen14) {
+            buffer[buf_index] = c_digits_lut[d1 + 1];
+            buf_index += 1;
+        }
+        if (value >= kTen13) {
+            buffer[buf_index] = c_digits_lut[d2];
+            buf_index += 1;
+        }
+        if (value >= kTen12) {
+            buffer[buf_index] = c_digits_lut[d2 + 1];
+            buf_index += 1;
+        }
+        if (value >= kTen11) {
+            buffer[buf_index] = c_digits_lut[d3];
+            buf_index += 1;
+        }
+        if (value >= kTen10) {
+            buffer[buf_index] = c_digits_lut[d3 + 1];
+            buf_index += 1;
+        }
+        if (value >= kTen9) {
+            buffer[buf_index] = c_digits_lut[d4];
+            buf_index += 1;
+        }
+        if (value >= kTen8) {
+            buffer[buf_index] = c_digits_lut[d4 + 1];
+            buf_index += 1;
+        }
+
+        buffer[buf_index] = c_digits_lut[d5];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d5 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d6];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d6 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d7];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d7 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d8];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d8];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d8];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d8 + 1];
+        buf_index += 1;
+    } else {
+        const a: u32 = (uint32_t)(value / kTen16);  // 1 to 1844
+        value %= kTen16;
+
+        if (a < 10) {
+            buffer[buf_index] = (char)('0' + (char)(a));
+            buf_index += 1;
+        } else if (a < 100) {
+            const i: u32 = a << 1;
+            buffer[buf_index] = c_digits_lut[i];
+            buf_index += 1;
+            buffer[buf_index] = c_digits_lut[i + 1];
+            buf_index += 1;
+        } else if (a < 1000) {
+            buffer[buf_index] = (char)('0' + (char)(a / 100));
+            buf_index += 1;
+
+            const i: u32 = (a % 100) << 1;
+            buffer[buf_index] = c_digits_lut[i];
+            buf_index += 1;
+            buffer[buf_index] = c_digits_lut[i + 1];
+            buf_index += 1;
+        } else {
+            const i: u32 = (a / 100) << 1;
+            const j: u32 = (a % 100) << 1;
+            buffer[buf_index] = c_digits_lut[i];
+            buf_index += 1;
+            buffer[buf_index] = c_digits_lut[i + 1];
+            buf_index += 1;
+            buffer[buf_index] = c_digits_lut[j];
+            buf_index += 1;
+            buffer[buf_index] = c_digits_lut[j + 1];
+            buf_index += 1;
+        }
+
+        const v0: u32 = (uint32_t)(value / kTen8);
+        const v1: u32 = (uint32_t)(value % kTen8);
+
+        const b0: u32 = v0 / 10000;
+        const c0: u32 = v0 % 10000;
+
+        const d1: u32 = (b0 / 100) << 1;
+        const d2: u32 = (b0 % 100) << 1;
+
+        const d3: u32 = (c0 / 100) << 1;
+        const d4: u32 = (c0 % 100) << 1;
+
+        const b1: u32 = v1 / 10000;
+        const c1: u32 = v1 % 10000;
+
+        const d5: u32 = (b1 / 100) << 1;
+        const d6: u32 = (b1 % 100) << 1;
+
+        const d7: u32 = (c1 / 100) << 1;
+        const d8: u32 = (c1 % 100) << 1;
+
+        buffer[buf_index] = c_digits_lut[d1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d1 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d2];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d2 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d3];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d3 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d4];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d4 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d5];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d5 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d6];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d6 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d7];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d7 + 1];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d8];
+        buf_index += 1;
+        buffer[buf_index] = c_digits_lut[d8 + 1];
+        buf_index += 1;
+    }
+
+    return buf_index;
+}
+
+fn fpeint(from: f64) -> u128 {
+    const bits = @bitCast(u64, from);
+    assert((bits & ((1 << 52) - 1)) == 0);
+
+    return 1 << ((bits >> 52) - 1023);
+}
+
+
+/// Given two different integers with the same length in terms of the number
+/// of decimal digits, index the digits from the right-most position starting
+/// from zero, find the first index where the digits in the two integers
+/// divergent starting from the highest index.
+///   @a: Integer a.
+///   @b: Integer b.
+///   &returns: An index within [0, 19).
+fn mismatch10(a: u64, b: u64) -> i32 {
+    const pow10 = 10000000000;
+    const af = a / pow10;
+    const bf = b / pow10;
+
+    var i: i32 = 0;
+    var a_copy = a;
+    var b_copy = b;
+
+    if (af != bf) {
+        i = 10;
+        a_copy = af;
+        b_copy = bf;
+    }
+
+    while (true) : (i += 1) {
+        a_copy /= 10;
+        b_copy /= 10;
+
+        if (a_copy == b_copy)
+            return i;
+    }
+}