IntTryClone

        out->negative = value->negative;
        out->exponent = value->exponent;
        if (!IntTryClone(&out->significand, &value->significand)) {
            FloatDeinit(out);
            *out = FloatInit(value->significand.bits.allocator);

        ValidateInt(value);
        *out = FloatInit(value->bits.allocator);
        if (!IntTryClone(&out->significand, value)) {
            FloatDeinit(out);
            *out = FloatInit(value->bits.allocator);

            Int factor = IntInit(value->significand.bits.allocator);
    
            if (!IntTryClone(&temp, &value->significand) ||
                !float_pow10(&factor, (u64)value->exponent, value->significand.bits.allocator) ||
                !int_mul(&temp, &temp, &factor)) {

    }
    
    bool IntTryClone(Int *out, Int *value) {
        return int_try_clone_value(out, value);
    }

            Int zero_rem   = IntInit(remainder->bits.allocator);
    
            if (!IntTryClone(&exact_root, value)) {
                IntDeinit(&exact_root);
                IntDeinit(&zero_rem);

    
                IntDeinit(&best);
                if (!IntTryClone(&best, &mid)) {
                    IntDeinit(&mid_pow);
                    IntDeinit(&mid);

        Int exp      = IntInit(exponent->bits.allocator);
    
        if (!int_try_from_u64_with_allocator(&acc, 1, result->bits.allocator) || !IntTryClone(&exp, exponent) ||
            !int_mod(&acc, &acc, modulus) || !int_mod(&base_mod, base, modulus)) {
            IntDeinit(&acc);

        bool      ok      = false;
    
        if (!IntTryClone(&r, modulus) || !int_mod(&reduced, value, modulus)) {
            IntDeinit(&reduced);
            IntDeinit(&r);

            return false;
        }
        if (!IntTryClone(&new_r, &reduced)) {
            IntDeinit(&reduced);
            IntDeinit(&r);

            Int root     = IntInit();
    
            if (!IntTryClone(&exponent, modulus) || !int_add_u64(&exponent, &exponent, 1) || !IntShiftRight(&exponent, 2) ||
                !int_pow_mod(&root, &a, &exponent, modulus)) {
                IntDeinit(&exponent);

            u64 m        = 0;
    
            if (!IntTryClone(&q, modulus) || !int_try_from_u64_with_allocator(&z, 2, modulus->bits.allocator) ||
                !int_sub_u64(&q, &q, 1)) {
                IntDeinit(&q);

            }
    
            if (!IntTryClone(&exponent, &q) || !int_add_u64(&exponent, &exponent, 1) || !IntShiftRight(&exponent, 1) ||
                !int_pow_mod(&r, &a, &exponent, modulus)) {
                IntDeinit(&q);

                u64 i       = 0;
    
                if (!IntTryClone(&t_power, &t)) {
                    IntDeinit(&t_power);
                    IntDeinit(&q);

                    Int next = IntInit();
    
                    if (!IntTryClone(&b, &c)) {
                        IntDeinit(&b);
                        IntDeinit(&b_sq);

            bool probable    = true;
    
            if (!IntTryClone(&d, value) || !int_sub_u64(&d, &d, 1)) {
                IntDeinit(&d);
                IntDeinit(&n_minus_one);

                return false;
            }
            if (!IntTryClone(&n_minus_one, &d)) {
                IntDeinit(&d);
                IntDeinit(&n_minus_one);

        Int candidate = IntInit(result->bits.allocator);
    
        if (!IntTryClone(&candidate, value)) {
            IntDeinit(&candidate);
            return false;