IntDeinit
Description
Release all storage owned by an integer. The object must not be used again until reinitialized.
Parameters
| Name | Direction | Description |
|---|---|---|
value |
in,out | Integer to deinitialize |
Success
Underlying bitvector freed; value left in the zeroed post-deinit state.
Failure
Cannot fail; aborts on a corrupted magic via the validator.
Usage example (Cross-references)
Usage examples (Cross-references)
- In
Init.h:46:
static inline void FloatDeinit(Float *value) {
ValidateFloat(value);
IntDeinit(&value->significand);
value->negative = false;
value->exponent = 0;- In
Io.c:3387:
}
IntDeinit(value);
*value = parsed;- In
Int.c:46:
if (!BitVecTryFromInteger(INT_BITS(out), value, bits, alloc)) {
IntDeinit(out);
*out = IntInit(alloc);
return false;- In
Int.c:137:
static void int_replace(Int *dst, Int *src) {
IntDeinit(dst);
*dst = *src;
}- In
Int.c:158:
static void sint_deinit(SignedInt *value) {
IntDeinit(&value->magnitude);
value->negative = false;
}- In
Int.c:266:
}
if (!int_try_from_u64(&rhs, factor, IntAllocator(value))) {
IntDeinit(&lhs);
return false;
}- In
Int.c:270:
}
if (!int_mul(&result, &lhs, &rhs)) {
IntDeinit(&lhs);
IntDeinit(&rhs);
IntDeinit(&result);- In
Int.c:271:
if (!int_mul(&result, &lhs, &rhs)) {
IntDeinit(&lhs);
IntDeinit(&rhs);
IntDeinit(&result);
return false;- In
Int.c:272:
IntDeinit(&lhs);
IntDeinit(&rhs);
IntDeinit(&result);
return false;
}- In
Int.c:276:
}
IntDeinit(&lhs);
IntDeinit(&rhs);
int_replace(value, &result);- In
Int.c:277:
IntDeinit(&lhs);
IntDeinit(&rhs);
int_replace(value, &result);
return true;- In
Int.c:291:
}
if (!int_try_from_u64(&rhs, addend, IntAllocator(value))) {
IntDeinit(&lhs);
return false;
}- In
Int.c:295:
}
if (!int_add(&result, &lhs, &rhs)) {
IntDeinit(&lhs);
IntDeinit(&rhs);
IntDeinit(&result);- In
Int.c:296:
if (!int_add(&result, &lhs, &rhs)) {
IntDeinit(&lhs);
IntDeinit(&rhs);
IntDeinit(&result);
return false;- In
Int.c:297:
IntDeinit(&lhs);
IntDeinit(&rhs);
IntDeinit(&result);
return false;
}- In
Int.c:301:
}
IntDeinit(&lhs);
IntDeinit(&rhs);
int_replace(value, &result);- In
Int.c:302:
IntDeinit(&lhs);
IntDeinit(&rhs);
int_replace(value, &result);
return true;- In
Int.c:367:
if (digit < 0 || digit >= radix) {
LOG_ERROR("Invalid digit for radix in Int conversion");
IntDeinit(&result);
return false;
}- In
Int.c:373:
saw_digit = true;
if (!int_mul_u64_in_place(&result, radix) || !int_add_u64_in_place(&result, (u64)digit)) {
IntDeinit(&result);
return false;
}- In
Int.c:380:
if (!saw_digit) {
LOG_ERROR("No valid digits found");
IntDeinit(&result);
return false;
}- In
Int.c:385:
int_normalize(&result);
IntDeinit(out);
*out = result;
return true;- In
Int.c:600:
for (u64 i = 0; i < len; i++) {
if (!IntShiftLeft(&result, 8) || !int_add_u64_in_place(&result, bytes[i])) {
IntDeinit(&result);
return IntInit(alloc);
}- In
Int.c:793:
if (!int_try_from_u64(&chunk_divisor, chunk, alloc) || !IntReserve("ient, IntBitLength(value))) {
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.c:794:
if (!int_try_from_u64(&chunk_divisor, chunk, alloc) || !IntReserve("ient, IntBitLength(value))) {
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);- In
Int.c:795:
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);- In
Int.c:796:
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);
return false;- In
Int.c:806:
if (!int_div_mod("ient, &remainder, ¤t, &chunk_divisor)) {
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.c:807:
if (!int_div_mod("ient, &remainder, ¤t, &chunk_divisor)) {
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);- In
Int.c:808:
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);- In
Int.c:809:
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);
return false;- In
Int.c:820:
for (u32 k = 0; (k < chunk_digits) && !(last && rem == 0 && k > 0); k++) {
if (!StrPushBackR(&result, int_radix_char((u8)(rem % radix), uppercase))) {
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.c:821:
if (!StrPushBackR(&result, int_radix_char((u8)(rem % radix), uppercase))) {
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);- In
Int.c:822:
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);- In
Int.c:823:
IntDeinit("ient);
IntDeinit(&remainder);
IntDeinit(¤t);
StrDeinit(&result);
return false;- In
Int.c:839:
}
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.c:840:
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.c:841:
IntDeinit(&chunk_divisor);
IntDeinit("ient);
IntDeinit(&remainder);
for (u64 i = 0; i < StrLen(&result) / 2; i++) {- In
Int.c:851:
}
IntDeinit(¤t);
*out = result;
return true;- In
Int.c:1311:
}
if (!int_add_u64_in_place(&temp, addend)) {
IntDeinit(&temp);
return false;
}- In
Int.c:1402:
}
ok = int_sub(result, value, &rhs);
IntDeinit(&rhs);
return ok;
}- In
Int.c:1501:
cleanup:
IntDeinit(&a_copy);
IntDeinit(&b_copy);
return ok;- In
Int.c:1502:
cleanup:
IntDeinit(&a_copy);
IntDeinit(&b_copy);
return ok;
}- In
Int.c:1516:
}
if (!int_mul_u64_in_place(&temp, factor)) {
IntDeinit(&temp);
return false;
}- In
Int.c:1559:
}
if (!int_try_clone_value(¤t, base)) {
IntDeinit(&acc);
return false;
}- In
Int.c:1571:
if (exponent & 1u) {
if (!int_mul(&scratch, &acc, ¤t)) {
IntDeinit(&acc);
IntDeinit(¤t);
IntDeinit(&scratch);- In
Int.c:1572:
if (!int_mul(&scratch, &acc, ¤t)) {
IntDeinit(&acc);
IntDeinit(¤t);
IntDeinit(&scratch);
return false;- In
Int.c:1573:
IntDeinit(&acc);
IntDeinit(¤t);
IntDeinit(&scratch);
return false;
}- In
Int.c:1582:
if (exponent > 0) {
if (!IntSquare(&scratch, ¤t)) {
IntDeinit(&acc);
IntDeinit(¤t);
IntDeinit(&scratch);- In
Int.c:1583:
if (!IntSquare(&scratch, ¤t)) {
IntDeinit(&acc);
IntDeinit(¤t);
IntDeinit(&scratch);
return false;- In
Int.c:1584:
IntDeinit(&acc);
IntDeinit(¤t);
IntDeinit(&scratch);
return false;
}- In
Int.c:1591:
}
IntDeinit(&scratch);
IntDeinit(¤t);
int_replace(result, &acc);- In
Int.c:1592:
IntDeinit(&scratch);
IntDeinit(¤t);
int_replace(result, &acc);
return true;- In
Int.c:1624:
if (!int_try_clone_value(&r0, dividend)) {
IntDeinit(&r0);
return false;
}- In
Int.c:1729:
cleanup:
IntDeinit(÷nd_copy);
IntDeinit(&divisor_copy);
return ok;- In
Int.c:1730:
cleanup:
IntDeinit(÷nd_copy);
IntDeinit(&divisor_copy);
return ok;
}- In
Int.c:1740:
// any input that aliases an output), so result's buffer is reused.
if (!int_div_mod(result, &remainder, dividend, divisor)) {
IntDeinit(&remainder);
return false;
}- In
Int.c:1744:
}
IntDeinit(&remainder);
return true;
}- In
Int.c:1762:
if (!int_div_mod("ient, &remainder, dividend, divisor)) {
IntDeinit("ient);
IntDeinit(&remainder);
return false;- In
Int.c:1763:
if (!int_div_mod("ient, &remainder, dividend, divisor)) {
IntDeinit("ient);
IntDeinit(&remainder);
return false;
}- In
Int.c:1767:
}
if (!IntIsZero(&remainder)) {
IntDeinit("ient);
IntDeinit(&remainder);
return false;- In
Int.c:1768:
if (!IntIsZero(&remainder)) {
IntDeinit("ient);
IntDeinit(&remainder);
return false;
}- In
Int.c:1772:
}
IntDeinit(&remainder);
int_replace(result, "ient);
return true;- In
Int.c:1781:
if (!int_try_from_u64(&divisor_value, divisor, IntAllocator(dividend))) {
IntDeinit(&divisor_value);
return false;
}- In
Int.c:1786:
bool ok = int_div(result, dividend, &divisor_value);
IntDeinit(&divisor_value);
return ok;
}- In
Int.c:1794:
if (!int_try_from_i64_with_allocator(&divisor_value, divisor, IntAllocator(dividend))) {
IntDeinit(&divisor_value);
return false;
}- In
Int.c:1799:
bool ok = int_div(result, dividend, &divisor_value);
IntDeinit(&divisor_value);
return ok;
}- In
Int.c:1807:
if (!int_try_from_u64(&divisor_value, divisor, IntAllocator(dividend))) {
IntDeinit(&divisor_value);
return false;
}- In
Int.c:1812:
bool ok = int_div_exact(result, dividend, &divisor_value);
IntDeinit(&divisor_value);
return ok;
}- In
Int.c:1820:
if (!int_try_from_i64_with_allocator(&divisor_value, divisor, IntAllocator(dividend))) {
IntDeinit(&divisor_value);
return false;
}- In
Int.c:1825:
bool ok = int_div_exact(result, dividend, &divisor_value);
IntDeinit(&divisor_value);
return ok;
}- In
Int.c:1833:
if (!int_try_from_u64(&divisor_value, divisor, IntAllocator(dividend))) {
IntDeinit(&divisor_value);
return false;
}- In
Int.c:1838:
bool ok = int_div_mod(quotient, remainder, dividend, &divisor_value);
IntDeinit(&divisor_value);
return ok;
}- In
Int.c:1846:
if (!int_try_from_i64_with_allocator(&divisor_value, divisor, IntAllocator(dividend))) {
IntDeinit(&divisor_value);
return false;
}- In
Int.c:1851:
bool ok = int_div_mod(quotient, remainder, dividend, &divisor_value);
IntDeinit(&divisor_value);
return ok;
}- In
Int.c:1869:
if (!int_try_from_u64(&divisor_value, divisor, IntAllocator(dividend))) {
IntDeinit(&divisor_value);
IntDeinit(&remainder);
return 0;- In
Int.c:1870:
if (!int_try_from_u64(&divisor_value, divisor, IntAllocator(dividend))) {
IntDeinit(&divisor_value);
IntDeinit(&remainder);
return 0;
}- In
Int.c:1875:
if (!int_div_mod(quotient, &remainder, dividend, &divisor_value)) {
IntDeinit(&divisor_value);
IntDeinit(&remainder);
return 0;- In
Int.c:1876:
if (!int_div_mod(quotient, &remainder, dividend, &divisor_value)) {
IntDeinit(&divisor_value);
IntDeinit(&remainder);
return 0;
}- In
Int.c:1881:
rem = IntToU64(&remainder);
IntDeinit(&divisor_value);
IntDeinit(&remainder);
return rem;- In
Int.c:1882:
IntDeinit(&divisor_value);
IntDeinit(&remainder);
return rem;
}- In
Int.c:1892:
// any input that aliases an output), so result's buffer is reused.
if (!int_div_mod("ient, result, dividend, divisor)) {
IntDeinit("ient);
return false;
}- In
Int.c:1896:
}
IntDeinit("ient);
return true;
}- In
Int.c:1904:
bool ok = int_div_mod_u64("ient, result, dividend, divisor);
IntDeinit("ient);
return ok;
}- In
Int.c:1912:
bool ok = int_div_mod_i64("ient, result, dividend, divisor);
IntDeinit("ient);
return ok;
}- In
Int.c:1927:
u64 rem = int_div_u64_rem("ient, value, modulus);
IntDeinit("ient);
return rem;
}- In
Int.c:1940:
if (!int_try_clone_value(&x, a) || !int_try_clone_value(&y, b)) {
IntDeinit(&x);
IntDeinit(&y);
return false;- In
Int.c:1941:
if (!int_try_clone_value(&x, a) || !int_try_clone_value(&y, b)) {
IntDeinit(&x);
IntDeinit(&y);
return false;
}- In
Int.c:1949:
if (!int_mod(&r, &x, &y)) {
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);- In
Int.c:1950:
if (!int_mod(&r, &x, &y)) {
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
return false;- In
Int.c:1951:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
return false;
}- In
Int.c:1954:
return false;
}
IntDeinit(&x);
x = y;
y = r;- In
Int.c:1960:
int_replace(result, &x);
IntDeinit(&y);
return true;
}- In
Int.c:1980:
if (!IntGCD(&gcd, a, b) || !int_div("ient, a, &gcd) || !int_mul(&lcm, "ient, b)) {
IntDeinit(&gcd);
IntDeinit("ient);
IntDeinit(&lcm);- In
Int.c:1981:
if (!IntGCD(&gcd, a, b) || !int_div("ient, a, &gcd) || !int_mul(&lcm, "ient, b)) {
IntDeinit(&gcd);
IntDeinit("ient);
IntDeinit(&lcm);
return false;- In
Int.c:1982:
IntDeinit(&gcd);
IntDeinit("ient);
IntDeinit(&lcm);
return false;
}- In
Int.c:1986:
}
IntDeinit(&gcd);
IntDeinit("ient);
int_replace(result, &lcm);- In
Int.c:1987:
IntDeinit(&gcd);
IntDeinit("ient);
int_replace(result, &lcm);
return true;- In
Int.c:2018:
if (!IntTryClone(&exact_root, value)) {
IntDeinit(&exact_root);
IntDeinit(&zero_rem);
return false;- In
Int.c:2019:
if (!IntTryClone(&exact_root, value)) {
IntDeinit(&exact_root);
IntDeinit(&zero_rem);
return false;
}- In
Int.c:2042:
if (!int_try_from_u64(&high, 1, IntAllocator(root)) || !int_try_from_u64(&one, 1, IntAllocator(root))) {
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);- In
Int.c:2043:
if (!int_try_from_u64(&high, 1, IntAllocator(root)) || !int_try_from_u64(&one, 1, IntAllocator(root))) {
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);- In
Int.c:2044:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;- In
Int.c:2045:
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;
}- In
Int.c:2050:
if (!IntShiftLeft(&high, high_shift)) {
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);- In
Int.c:2051:
if (!IntShiftLeft(&high, high_shift)) {
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);- In
Int.c:2052:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;- In
Int.c:2053:
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;
}- In
Int.c:2064:
if (!int_add(&sum, &low, &high) || !IntShiftRight(&sum, 1)) {
IntDeinit(&sum);
IntDeinit(&mid);
IntDeinit(&mid_pow);- In
Int.c:2065:
if (!int_add(&sum, &low, &high) || !IntShiftRight(&sum, 1)) {
IntDeinit(&sum);
IntDeinit(&mid);
IntDeinit(&mid_pow);
IntDeinit(&low);- In
Int.c:2066:
IntDeinit(&sum);
IntDeinit(&mid);
IntDeinit(&mid_pow);
IntDeinit(&low);
IntDeinit(&high);- In
Int.c:2067:
IntDeinit(&mid);
IntDeinit(&mid_pow);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);- In
Int.c:2068:
IntDeinit(&mid_pow);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);- In
Int.c:2069:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;- In
Int.c:2070:
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;
}- In
Int.c:2076:
if (!int_pow_u64(&mid_pow, &mid, degree)) {
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&low);- In
Int.c:2077:
if (!int_pow_u64(&mid_pow, &mid, degree)) {
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&low);
IntDeinit(&high);- In
Int.c:2078:
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);- In
Int.c:2079:
IntDeinit(&mid);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);- In
Int.c:2080:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;- In
Int.c:2081:
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;
}- In
Int.c:2089:
Int next = IntInit(IntAllocator(root));
IntDeinit(&best);
if (!IntTryClone(&best, &mid)) {
IntDeinit(&mid_pow);- In
Int.c:2091:
IntDeinit(&best);
if (!IntTryClone(&best, &mid)) {
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);- In
Int.c:2092:
if (!IntTryClone(&best, &mid)) {
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);- In
Int.c:2093:
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);- In
Int.c:2094:
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);- In
Int.c:2095:
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);- In
Int.c:2096:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;- In
Int.c:2097:
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;
}- In
Int.c:2101:
}
if (!int_add(&next, &mid, &one)) {
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);- In
Int.c:2102:
if (!int_add(&next, &mid, &one)) {
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);- In
Int.c:2103:
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);- In
Int.c:2104:
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);- In
Int.c:2105:
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);- In
Int.c:2106:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;- In
Int.c:2107:
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;
}- In
Int.c:2110:
return false;
}
IntDeinit(&low);
low = next;
} else {- In
Int.c:2116:
if (IntEQ(&mid, &one) || IntIsZero(&mid)) {
IntDeinit(&high);
high = IntInit(IntAllocator(root));
} else {- In
Int.c:2120:
} else {
if (!int_sub(&next, &mid, &one)) {
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);- In
Int.c:2121:
if (!int_sub(&next, &mid, &one)) {
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);- In
Int.c:2122:
IntDeinit(&mid_pow);
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);- In
Int.c:2123:
IntDeinit(&mid);
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);- In
Int.c:2124:
IntDeinit(&next);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);- In
Int.c:2125:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;- In
Int.c:2126:
IntDeinit(&high);
IntDeinit(&best);
IntDeinit(&one);
return false;
}- In
Int.c:2129:
return false;
}
IntDeinit(&high);
high = next;
}- In
Int.c:2134:
}
IntDeinit(&mid_pow);
IntDeinit(&mid);
}- In
Int.c:2135:
IntDeinit(&mid_pow);
IntDeinit(&mid);
}- In
Int.c:2143:
if (!int_pow_u64(&power, &best, degree) || !int_sub(&rem, value, &power)) {
IntDeinit(&power);
IntDeinit(&rem);
IntDeinit(&low);- In
Int.c:2144:
if (!int_pow_u64(&power, &best, degree) || !int_sub(&rem, value, &power)) {
IntDeinit(&power);
IntDeinit(&rem);
IntDeinit(&low);
IntDeinit(&high);- In
Int.c:2145:
IntDeinit(&power);
IntDeinit(&rem);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&one);- In
Int.c:2146:
IntDeinit(&rem);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&one);
IntDeinit(&best);- In
Int.c:2147:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&one);
IntDeinit(&best);
return false;- In
Int.c:2148:
IntDeinit(&high);
IntDeinit(&one);
IntDeinit(&best);
return false;
}- In
Int.c:2152:
}
IntDeinit(&power);
IntDeinit(&low);
IntDeinit(&high);- In
Int.c:2153:
IntDeinit(&power);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&one);- In
Int.c:2154:
IntDeinit(&power);
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&one);- In
Int.c:2155:
IntDeinit(&low);
IntDeinit(&high);
IntDeinit(&one);
int_replace(root, &best);- In
Int.c:2169:
if (!IntRootRem(&root, &remainder, value, degree)) {
IntDeinit(&root);
IntDeinit(&remainder);
return false;- In
Int.c:2170:
if (!IntRootRem(&root, &remainder, value, degree)) {
IntDeinit(&root);
IntDeinit(&remainder);
return false;
}- In
Int.c:2174:
}
IntDeinit(&remainder);
int_replace(result, &root);
return true;- In
Int.c:2195:
if (!IntSqrtRem(&root, &remainder, value)) {
IntDeinit(&root);
IntDeinit(&remainder);
return false;- In
Int.c:2196:
if (!IntSqrtRem(&root, &remainder, value)) {
IntDeinit(&root);
IntDeinit(&remainder);
return false;
}- In
Int.c:2201:
result = IntIsZero(&remainder);
IntDeinit(&root);
IntDeinit(&remainder);
return result;- In
Int.c:2202:
IntDeinit(&root);
IntDeinit(&remainder);
return result;
}- In
Int.c:2225:
if (!IntRootRem(&root, &remainder, value, degree)) {
IntDeinit(&root);
IntDeinit(&remainder);
return false;- In
Int.c:2226:
if (!IntRootRem(&root, &remainder, value, degree)) {
IntDeinit(&root);
IntDeinit(&remainder);
return false;
}- In
Int.c:2231:
exact = IntIsZero(&remainder);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.c:2232:
IntDeinit(&root);
IntDeinit(&remainder);
if (exact) {- In
Int.c:2260:
if (!int_try_clone_value(&nn, n) || !int_mod(&aa, a, &nn)) {
IntDeinit(&aa);
IntDeinit(&nn);
return false;- In
Int.c:2261:
if (!int_try_clone_value(&nn, n) || !int_mod(&aa, a, &nn)) {
IntDeinit(&aa);
IntDeinit(&nn);
return false;
}- In
Int.c:2270:
if (!IntShiftRight(&aa, 1)) {
IntDeinit(&aa);
IntDeinit(&nn);
return false;- In
Int.c:2271:
if (!IntShiftRight(&aa, 1)) {
IntDeinit(&aa);
IntDeinit(&nn);
return false;
}- In
Int.c:2287:
if (!int_mod(&aa, &aa, &nn)) {
IntDeinit(&aa);
IntDeinit(&nn);
return false;- In
Int.c:2288:
if (!int_mod(&aa, &aa, &nn)) {
IntDeinit(&aa);
IntDeinit(&nn);
return false;
}- In
Int.c:2293:
}
IntDeinit(&aa);
if (int_compare_u64(&nn, 1) != 0) {
IntDeinit(&nn);- In
Int.c:2295:
IntDeinit(&aa);
if (int_compare_u64(&nn, 1) != 0) {
IntDeinit(&nn);
*out = 0;
return true;- In
Int.c:2300:
}
IntDeinit(&nn);
*out = result;
return true;- In
Int.c:2363:
done:
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&sum);- In
Int.c:2364:
done:
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&sum);
return ok;- In
Int.c:2365:
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&sum);
return ok;
}- In
Int.c:2384:
if (!int_mod(&ar, a, modulus) || !int_mod(&br, b, modulus)) {
IntDeinit(&ar);
IntDeinit(&br);
return false;- In
Int.c:2385:
if (!int_mod(&ar, a, modulus) || !int_mod(&br, b, modulus)) {
IntDeinit(&ar);
IntDeinit(&br);
return false;
}- In
Int.c:2391:
if (IntGE(&ar, &br)) {
if (!int_sub(result, &ar, &br)) {
IntDeinit(&ar);
IntDeinit(&br);
return false;- In
Int.c:2392:
if (!int_sub(result, &ar, &br)) {
IntDeinit(&ar);
IntDeinit(&br);
return false;
}- In
Int.c:2399:
if (!int_sub(&diff, &br, &ar)) {
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&diff);- In
Int.c:2400:
if (!int_sub(&diff, &br, &ar)) {
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&diff);
return false;- In
Int.c:2401:
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&diff);
return false;
}- In
Int.c:2409:
} else {
if (!int_sub(result, modulus, &diff)) {
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&diff);- In
Int.c:2410:
if (!int_sub(result, modulus, &diff)) {
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&diff);
return false;- In
Int.c:2411:
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&diff);
return false;
}- In
Int.c:2416:
}
IntDeinit(&diff);
}- In
Int.c:2419:
}
IntDeinit(&ar);
IntDeinit(&br);
return true;- In
Int.c:2420:
IntDeinit(&ar);
IntDeinit(&br);
return true;
}- In
Int.c:2463:
done:
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&prod);- In
Int.c:2464:
done:
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&prod);
return ok;- In
Int.c:2465:
IntDeinit(&ar);
IntDeinit(&br);
IntDeinit(&prod);
return ok;
}- In
Int.c:2486:
ok = IntModInv(&inverse, b, modulus);
if (!ok) {
IntDeinit(&inverse);
IntDeinit(&value);
return false;- In
Int.c:2487:
if (!ok) {
IntDeinit(&inverse);
IntDeinit(&value);
return false;
}- In
Int.c:2492:
if (!IntModMul(&value, a, &inverse, modulus)) {
IntDeinit(&inverse);
IntDeinit(&value);
return false;- In
Int.c:2493:
if (!IntModMul(&value, a, &inverse, modulus)) {
IntDeinit(&inverse);
IntDeinit(&value);
return false;
}- In
Int.c:2497:
}
IntDeinit(&inverse);
int_replace(result, &value);
return true;- In
Int.c:2519:
if (!int_try_from_u64(&acc, 1, IntAllocator(result))) {
IntDeinit(&base_mod);
return false;
}- In
Int.c:2523:
}
if (!int_mod(&acc, &acc, modulus) || !int_mod(&base_mod, base, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
return false;- In
Int.c:2524:
if (!int_mod(&acc, &acc, modulus) || !int_mod(&base_mod, base, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
return false;
}- In
Int.c:2533:
if (exponent & 1u) {
if (!IntModMul(&scratch, &acc, &base_mod, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&scratch);- In
Int.c:2534:
if (!IntModMul(&scratch, &acc, &base_mod, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&scratch);
return false;- In
Int.c:2535:
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&scratch);
return false;
}- In
Int.c:2544:
if (exponent > 0) {
if (!IntModMul(&scratch, &base_mod, &base_mod, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&scratch);- In
Int.c:2545:
if (!IntModMul(&scratch, &base_mod, &base_mod, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&scratch);
return false;- In
Int.c:2546:
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&scratch);
return false;
}- In
Int.c:2553:
}
IntDeinit(&scratch);
IntDeinit(&base_mod);
int_replace(result, &acc);- In
Int.c:2554:
IntDeinit(&scratch);
IntDeinit(&base_mod);
int_replace(result, &acc);
return true;- In
Int.c:2576:
if (!int_try_from_u64(&acc, 1, IntAllocator(result)) || !IntTryClone(&exp, exponent) ||
!int_mod(&acc, &acc, modulus) || !int_mod(&base_mod, base, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);- In
Int.c:2577:
!int_mod(&acc, &acc, modulus) || !int_mod(&base_mod, base, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);
return false;- In
Int.c:2578:
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);
return false;
}- In
Int.c:2587:
if (int_is_odd(&exp)) {
if (!IntModMul(&scratch, &acc, &base_mod, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);- In
Int.c:2588:
if (!IntModMul(&scratch, &acc, &base_mod, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);- In
Int.c:2589:
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);
return false;- In
Int.c:2590:
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);
return false;
}- In
Int.c:2597:
if (!IntShiftRight(&exp, 1)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);- In
Int.c:2598:
if (!IntShiftRight(&exp, 1)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);- In
Int.c:2599:
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);
return false;- In
Int.c:2600:
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);
return false;
}- In
Int.c:2605:
if (!IntIsZero(&exp)) {
if (!IntModMul(&scratch, &base_mod, &base_mod, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);- In
Int.c:2606:
if (!IntModMul(&scratch, &base_mod, &base_mod, modulus)) {
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);- In
Int.c:2607:
IntDeinit(&acc);
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);
return false;- In
Int.c:2608:
IntDeinit(&base_mod);
IntDeinit(&exp);
IntDeinit(&scratch);
return false;
}- In
Int.c:2615:
}
IntDeinit(&scratch);
IntDeinit(&exp);
IntDeinit(&base_mod);- In
Int.c:2616:
IntDeinit(&scratch);
IntDeinit(&exp);
IntDeinit(&base_mod);
int_replace(result, &acc);- In
Int.c:2617:
IntDeinit(&scratch);
IntDeinit(&exp);
IntDeinit(&base_mod);
int_replace(result, &acc);
return true;- In
Int.c:2649:
if (!IntTryClone(&r, modulus) || !int_mod(&reduced, value, modulus)) {
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);- In
Int.c:2650:
if (!IntTryClone(&r, modulus) || !int_mod(&reduced, value, modulus)) {
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);- In
Int.c:2651:
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);- In
Int.c:2652:
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);
sint_deinit(&new_t);- In
Int.c:2658:
}
if (!IntTryClone(&new_r, &reduced)) {
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);- In
Int.c:2659:
if (!IntTryClone(&new_r, &reduced)) {
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);- In
Int.c:2660:
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);- In
Int.c:2661:
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);
sint_deinit(&new_t);- In
Int.c:2676:
if (!int_div_mod(&q, &rem, &r, &new_r) || !sint_mul_unsigned(&q_new_t, &new_t, &q) ||
!sint_sub(&next_t, &t, &q_new_t)) {
IntDeinit(&q);
IntDeinit(&rem);
IntDeinit(&next_r);- In
Int.c:2677:
!sint_sub(&next_t, &t, &q_new_t)) {
IntDeinit(&q);
IntDeinit(&rem);
IntDeinit(&next_r);
sint_deinit(&q_new_t);- In
Int.c:2678:
IntDeinit(&q);
IntDeinit(&rem);
IntDeinit(&next_r);
sint_deinit(&q_new_t);
sint_deinit(&next_t);- In
Int.c:2681:
sint_deinit(&q_new_t);
sint_deinit(&next_t);
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);- In
Int.c:2682:
sint_deinit(&next_t);
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);- In
Int.c:2683:
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);- In
Int.c:2684:
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);
sint_deinit(&new_t);- In
Int.c:2690:
}
IntDeinit(&next_r);
next_r = rem;- In
Int.c:2697:
new_t = next_t;
IntDeinit(&r);
r = new_r;
new_r = next_r;- In
Int.c:2702:
sint_deinit(&q_new_t);
IntDeinit(&q);
}- In
Int.c:2710:
if (!int_mod(&mag_mod, &t.magnitude, modulus)) {
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);- In
Int.c:2711:
if (!int_mod(&mag_mod, &t.magnitude, modulus)) {
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);- In
Int.c:2712:
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);- In
Int.c:2713:
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);- In
Int.c:2714:
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);- In
Int.c:2715:
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);
sint_deinit(&new_t);- In
Int.c:2722:
if (t.negative && !IntIsZero(&mag_mod)) {
if (!int_sub(&positive, modulus, &mag_mod)) {
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);- In
Int.c:2723:
if (!int_sub(&positive, modulus, &mag_mod)) {
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);- In
Int.c:2724:
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);- In
Int.c:2725:
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);- In
Int.c:2726:
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);- In
Int.c:2727:
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);
sint_deinit(&new_t);- In
Int.c:2734:
} else {
if (!int_mod(&positive, &t.magnitude, modulus)) {
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);- In
Int.c:2735:
if (!int_mod(&positive, &t.magnitude, modulus)) {
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);- In
Int.c:2736:
IntDeinit(&positive);
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);- In
Int.c:2737:
IntDeinit(&mag_mod);
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);- In
Int.c:2738:
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);- In
Int.c:2739:
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);
sint_deinit(&new_t);- In
Int.c:2746:
}
IntDeinit(&mag_mod);
int_replace(result, &positive);
ok = true;- In
Int.c:2751:
}
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);- In
Int.c:2752:
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);- In
Int.c:2753:
IntDeinit(&reduced);
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);- In
Int.c:2754:
IntDeinit(&r);
IntDeinit(&new_r);
IntDeinit(&one);
sint_deinit(&t);
sint_deinit(&new_t);- In
Int.c:2774:
if (!int_mod(&a, value, modulus)) {
IntDeinit(&a);
return false;
}- In
Int.c:2781:
Int zero = IntInit(IntAllocator(result));
int_replace(result, &zero);
IntDeinit(&a);
return true;
}- In
Int.c:2793:
if (prime_error) {
IntDeinit(&a);
return false;
}- In
Int.c:2797:
}
if (IntIsEven(modulus) || !prime) {
IntDeinit(&a);
return false;
}- In
Int.c:2804:
int jacobi = 0;
if (!IntTryJacobi(&jacobi, &a, modulus) || jacobi != 1) {
IntDeinit(&a);
return false;
}- In
Int.c:2814:
if (!IntTryClone(&exponent, modulus) || !int_add_u64(&exponent, &exponent, 1) || !IntShiftRight(&exponent, 2) ||
!int_pow_mod(&root, &a, &exponent, modulus)) {
IntDeinit(&exponent);
IntDeinit(&root);
IntDeinit(&a);- In
Int.c:2815:
!int_pow_mod(&root, &a, &exponent, modulus)) {
IntDeinit(&exponent);
IntDeinit(&root);
IntDeinit(&a);
return false;- In
Int.c:2816:
IntDeinit(&exponent);
IntDeinit(&root);
IntDeinit(&a);
return false;
}- In
Int.c:2820:
}
IntDeinit(&exponent);
IntDeinit(&a);
int_replace(result, &root);- In
Int.c:2821:
IntDeinit(&exponent);
IntDeinit(&a);
int_replace(result, &root);
return true;- In
Int.c:2836:
if (!IntTryClone(&q, modulus) || !int_try_from_u64(&z, 2, IntAllocator(modulus)) || !int_sub_u64(&q, &q, 1)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2837:
if (!IntTryClone(&q, modulus) || !int_try_from_u64(&z, 2, IntAllocator(modulus)) || !int_sub_u64(&q, &q, 1)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2838:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2839:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2840:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2841:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2842:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2847:
while (IntIsEven(&q)) {
if (!IntShiftRight(&q, 1)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2848:
if (!IntShiftRight(&q, 1)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2849:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2850:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2851:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2852:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2853:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2863:
if (!IntTryJacobi(&jacobi, &z, modulus)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2864:
if (!IntTryJacobi(&jacobi, &z, modulus)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2865:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2866:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2867:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2868:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2869:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2878:
if (!int_add_u64(&z, &z, 1)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2879:
if (!int_add_u64(&z, &z, 1)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2880:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2881:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2882:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2883:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2884:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2890:
if (!int_pow_mod(&c, &z, &q, modulus) || !int_pow_mod(&t, &a, &q, modulus)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2891:
if (!int_pow_mod(&c, &z, &q, modulus) || !int_pow_mod(&t, &a, &q, modulus)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2892:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2893:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2894:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2895:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2896:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2902:
if (!IntTryClone(&exponent, &q) || !int_add_u64(&exponent, &exponent, 1) || !IntShiftRight(&exponent, 1) ||
!int_pow_mod(&r, &a, &exponent, modulus)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2903:
!int_pow_mod(&r, &a, &exponent, modulus)) {
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2904:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2905:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2906:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2907:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2908:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2917:
if (!IntTryClone(&t_power, &t)) {
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);- In
Int.c:2918:
if (!IntTryClone(&t_power, &t)) {
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2919:
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2920:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2921:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2922:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2923:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2924:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2932:
for (i = 1; i < m; i++) {
if (!IntSquareMod(&scratch, &t_power, modulus)) {
IntDeinit(&scratch);
IntDeinit(&t_power);
IntDeinit(&q);- In
Int.c:2933:
if (!IntSquareMod(&scratch, &t_power, modulus)) {
IntDeinit(&scratch);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);- In
Int.c:2934:
IntDeinit(&scratch);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2935:
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2936:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2937:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2938:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2939:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2940:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2950:
}
IntDeinit(&scratch);
if (i == m) {- In
Int.c:2953:
if (i == m) {
IntDeinit(&t_power);
break;
}- In
Int.c:2963:
if (!IntTryClone(&b, &c)) {
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);- In
Int.c:2964:
if (!IntTryClone(&b, &c)) {
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);- In
Int.c:2965:
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);- In
Int.c:2966:
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);- In
Int.c:2967:
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2968:
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2969:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2970:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2971:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2972:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2973:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2981:
if (!IntSquareMod(&square, &b, modulus)) {
IntDeinit(&square);
IntDeinit(&b);
IntDeinit(&b_sq);- In
Int.c:2982:
if (!IntSquareMod(&square, &b, modulus)) {
IntDeinit(&square);
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);- In
Int.c:2983:
IntDeinit(&square);
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);- In
Int.c:2984:
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);- In
Int.c:2985:
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);- In
Int.c:2986:
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:2987:
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:2988:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:2989:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:2990:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:2991:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:2992:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:2995:
return false;
}
IntDeinit(&b);
b = square;
}- In
Int.c:3000:
if (!IntModMul(&next, &r, &b, modulus)) {
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);- In
Int.c:3001:
if (!IntModMul(&next, &r, &b, modulus)) {
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);- In
Int.c:3002:
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);- In
Int.c:3003:
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);- In
Int.c:3004:
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:3005:
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:3006:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:3007:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:3008:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:3009:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:3010:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:3013:
return false;
}
IntDeinit(&r);
r = next;- In
Int.c:3017:
if (!IntSquareMod(&b_sq, &b, modulus)) {
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&t_power);- In
Int.c:3018:
if (!IntSquareMod(&b_sq, &b, modulus)) {
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&t_power);
IntDeinit(&q);- In
Int.c:3019:
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);- In
Int.c:3020:
IntDeinit(&b_sq);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:3021:
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:3022:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:3023:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:3024:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:3025:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:3026:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:3031:
next = IntInit(IntAllocator(result));
if (!IntModMul(&next, &t, &b_sq, modulus)) {
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);- In
Int.c:3032:
if (!IntModMul(&next, &t, &b_sq, modulus)) {
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);- In
Int.c:3033:
IntDeinit(&b);
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);- In
Int.c:3034:
IntDeinit(&b_sq);
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);- In
Int.c:3035:
IntDeinit(&next);
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:3036:
IntDeinit(&t_power);
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:3037:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);- In
Int.c:3038:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);- In
Int.c:3039:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:3040:
IntDeinit(&t);
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;- In
Int.c:3041:
IntDeinit(&r);
IntDeinit(&exponent);
IntDeinit(&a);
return false;
}- In
Int.c:3044:
return false;
}
IntDeinit(&t);
t = next;- In
Int.c:3047:
t = next;
IntDeinit(&c);
c = b_sq;
IntDeinit(&b);- In
Int.c:3049:
IntDeinit(&c);
c = b_sq;
IntDeinit(&b);
}- In
Int.c:3052:
}
IntDeinit(&t_power);
m = i;
}- In
Int.c:3057:
ok = int_compare_u64(&t, 1) == 0;
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);- In
Int.c:3058:
ok = int_compare_u64(&t, 1) == 0;
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);- In
Int.c:3059:
IntDeinit(&q);
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&exponent);- In
Int.c:3060:
IntDeinit(&z);
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:3061:
IntDeinit(&c);
IntDeinit(&t);
IntDeinit(&exponent);
IntDeinit(&a);- In
Int.c:3062:
IntDeinit(&t);
IntDeinit(&exponent);
IntDeinit(&a);
if (ok) {- In
Int.c:3067:
int_replace(result, &r);
} else {
IntDeinit(&r);
}
}- In
Int.c:3108:
if (!IntTryClone(&d, value) || !int_sub_u64(&d, &d, 1)) {
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;- In
Int.c:3109:
if (!IntTryClone(&d, value) || !int_sub_u64(&d, &d, 1)) {
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;
}- In
Int.c:3113:
}
if (!IntTryClone(&n_minus_one, &d)) {
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;- In
Int.c:3114:
if (!IntTryClone(&n_minus_one, &d)) {
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;
}- In
Int.c:3120:
while (IntIsEven(&d)) {
if (!IntShiftRight(&d, 1)) {
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;- In
Int.c:3121:
if (!IntShiftRight(&d, 1)) {
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;
}- In
Int.c:3132:
if (!int_try_from_u64(&base, bases[i], IntAllocator(value))) {
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);- In
Int.c:3133:
if (!int_try_from_u64(&base, bases[i], IntAllocator(value))) {
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);- In
Int.c:3134:
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;- In
Int.c:3135:
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;
}- In
Int.c:3140:
if (int_compare(&base, value) >= 0) {
IntDeinit(&base);
IntDeinit(&x);
continue;- In
Int.c:3141:
if (int_compare(&base, value) >= 0) {
IntDeinit(&base);
IntDeinit(&x);
continue;
}- In
Int.c:3146:
if (!int_pow_mod(&x, &base, &d, value)) {
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);- In
Int.c:3147:
if (!int_pow_mod(&x, &base, &d, value)) {
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);- In
Int.c:3148:
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;- In
Int.c:3149:
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;
}- In
Int.c:3153:
}
if ((int_compare_u64(&x, 1) == 0) || IntEQ(&x, &n_minus_one)) {
IntDeinit(&base);
IntDeinit(&x);
continue;- In
Int.c:3154:
if ((int_compare_u64(&x, 1) == 0) || IntEQ(&x, &n_minus_one)) {
IntDeinit(&base);
IntDeinit(&x);
continue;
}- In
Int.c:3165:
if (!IntSquareMod(&next, &x, value)) {
IntDeinit(&next);
IntDeinit(&base);
IntDeinit(&x);- In
Int.c:3166:
if (!IntSquareMod(&next, &x, value)) {
IntDeinit(&next);
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);- In
Int.c:3167:
IntDeinit(&next);
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);- In
Int.c:3168:
IntDeinit(&base);
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;- In
Int.c:3169:
IntDeinit(&x);
IntDeinit(&d);
IntDeinit(&n_minus_one);
return false;
}- In
Int.c:3172:
return false;
}
IntDeinit(&x);
x = next;- In
Int.c:3186:
}
IntDeinit(&base);
IntDeinit(&x);
if (!probable) {- In
Int.c:3187:
IntDeinit(&base);
IntDeinit(&x);
if (!probable) {
break;- In
Int.c:3193:
}
IntDeinit(&d);
IntDeinit(&n_minus_one);
return probable;- In
Int.c:3194:
IntDeinit(&d);
IntDeinit(&n_minus_one);
return probable;
}- In
Int.c:3209:
if (!int_try_from_u64(&two, 2, IntAllocator(result))) {
IntDeinit(&two);
return false;
}- In
Int.c:3219:
if (!IntTryClone(&candidate, value)) {
IntDeinit(&candidate);
return false;
}- In
Int.c:3224:
if (!int_add_u64(&candidate, &candidate, 1)) {
IntDeinit(&candidate);
return false;
}- In
Int.c:3231:
if (!int_try_from_u64(&two, 2, IntAllocator(result))) {
IntDeinit(&two);
IntDeinit(&candidate);
return false;- In
Int.c:3232:
if (!int_try_from_u64(&two, 2, IntAllocator(result))) {
IntDeinit(&two);
IntDeinit(&candidate);
return false;
}- In
Int.c:3235:
return false;
}
IntDeinit(&candidate);
int_replace(result, &two);
return true;- In
Int.c:3241:
if (IntIsEven(&candidate)) {
if (!int_add_u64(&candidate, &candidate, 1)) {
IntDeinit(&candidate);
return false;
}- In
Int.c:3248:
while (!IntIsProbablePrimeWithError(&candidate, &error)) {
if (error) {
IntDeinit(&candidate);
return false;
}- In
Int.c:3252:
}
if (!int_add_u64(&candidate, &candidate, 2)) {
IntDeinit(&candidate);
return false;
}- In
Float.c:82:
if (!int_try_from_u64(&five, 5u, alloc) || !IntPow(&pow5, &five, n) ||
!int_mul(&sig, &out->significand, &pow5)) {
IntDeinit(&five);
IntDeinit(&pow5);
IntDeinit(&sig);- In
Float.c:83:
!int_mul(&sig, &out->significand, &pow5)) {
IntDeinit(&five);
IntDeinit(&pow5);
IntDeinit(&sig);
return false;- In
Float.c:84:
IntDeinit(&five);
IntDeinit(&pow5);
IntDeinit(&sig);
return false;
}- In
Float.c:87:
return false;
}
IntDeinit(&five);
IntDeinit(&pow5);
IntDeinit(&out->significand);- In
Float.c:88:
}
IntDeinit(&five);
IntDeinit(&pow5);
IntDeinit(&out->significand);
out->significand = sig;- In
Float.c:89:
IntDeinit(&five);
IntDeinit(&pow5);
IntDeinit(&out->significand);
out->significand = sig;
out->exponent = (i64)binexp;- In
Float.c:169:
}
if (!int_try_from_u64(&base, 10, alloc) || !int_try_from_u64(&result, 1, alloc)) {
IntDeinit(&base);
IntDeinit(&result);
return false;- In
Float.c:170:
if (!int_try_from_u64(&base, 10, alloc) || !int_try_from_u64(&result, 1, alloc)) {
IntDeinit(&base);
IntDeinit(&result);
return false;
}- In
Float.c:175:
if (!int_pow_u64(&result, &base, power)) {
IntDeinit(&base);
IntDeinit(&result);
return false;- In
Float.c:176:
if (!int_pow_u64(&result, &base, power)) {
IntDeinit(&base);
IntDeinit(&result);
return false;
}- In
Float.c:179:
return false;
}
IntDeinit(&base);
*out = result;
return true;- In
Float.c:204:
if (!float_pow10(&factor, places, FloatAllocator(value)) || !int_mul(&scaled, &value->significand, &factor)) {
IntDeinit(&factor);
IntDeinit(&scaled);
return false;- In
Float.c:205:
if (!float_pow10(&factor, places, FloatAllocator(value)) || !int_mul(&scaled, &value->significand, &factor)) {
IntDeinit(&factor);
IntDeinit(&scaled);
return false;
}- In
Float.c:208:
return false;
}
IntDeinit(&factor);
IntDeinit(&value->significand);- In
Float.c:209:
}
IntDeinit(&factor);
IntDeinit(&value->significand);
value->significand = scaled;- In
Float.c:291:
}
IntDeinit(&ten);
IntDeinit(&q);
IntDeinit(&r);- In
Float.c:292:
IntDeinit(&ten);
IntDeinit(&q);
IntDeinit(&r);
}- In
Float.c:293:
IntDeinit(&ten);
IntDeinit(&q);
IntDeinit(&r);
}
}- In
Float.c:440:
if (FloatIsNegative(value)) {
IntDeinit(&temp);
return false;
}- In
Float.c:445:
if (FloatIsZero(value)) {
IntDeinit(result);
*result = temp;
return true;- In
Float.c:455:
if (!IntTryClone(&temp, &value->significand) ||
!float_pow10(&factor, (u64)value->exponent, FloatAllocator(value)) || !int_mul(&temp, &temp, &factor)) {
IntDeinit(&factor);
IntDeinit(&temp);
return false;- In
Float.c:456:
!float_pow10(&factor, (u64)value->exponent, FloatAllocator(value)) || !int_mul(&temp, &temp, &factor)) {
IntDeinit(&factor);
IntDeinit(&temp);
return false;
}- In
Float.c:460:
}
IntDeinit(&factor);
IntDeinit(result);
*result = temp;- In
Float.c:461:
IntDeinit(&factor);
IntDeinit(result);
*result = temp;
return true;- In
Float.c:472:
if (!float_pow10(&factor, places, FloatAllocator(value))) {
IntDeinit(&factor);
return false;
}- In
Float.c:476:
}
ok = int_div_exact(&temp, &value->significand, &factor);
IntDeinit(&factor);
if (!ok) {
IntDeinit(&temp);- In
Float.c:478:
IntDeinit(&factor);
if (!ok) {
IntDeinit(&temp);
return false;
}- In
Float.c:483:
}
IntDeinit(result);
*result = temp;
return true;- In
Float.c:1213:
if (!float_pow10(&scale, precision, FloatAllocator(result)) || !int_mul(&scaled, &a->significand, &scale)) {
IntDeinit(&scale);
IntDeinit(&scaled);
FloatDeinit(&temp);- In
Float.c:1214:
if (!float_pow10(&scale, precision, FloatAllocator(result)) || !int_mul(&scaled, &a->significand, &scale)) {
IntDeinit(&scale);
IntDeinit(&scaled);
FloatDeinit(&temp);
return false;- In
Float.c:1219:
}
if (!int_div(&temp.significand, &scaled, &b->significand)) {
IntDeinit(&scale);
IntDeinit(&scaled);
FloatDeinit(&temp);- In
Float.c:1220:
if (!int_div(&temp.significand, &scaled, &b->significand)) {
IntDeinit(&scale);
IntDeinit(&scaled);
FloatDeinit(&temp);
return false;- In
Float.c:1228:
temp.exponent = float_sub_i64_checked(float_sub_i64_checked(a->exponent, b->exponent), (i64)precision);
IntDeinit(&scale);
IntDeinit(&scaled);- In
Float.c:1229:
IntDeinit(&scale);
IntDeinit(&scaled);
float_normalize(&temp);- In
Int.Type.c:26:
result = result && (IntBitLength(&value) == 0);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Type.c:43:
result = result && (IntBitLength(&value) == 0);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Type.c:65:
result = result && (IntToU64(&original) == 22);
IntDeinit(&original);
IntDeinit(&clone);
DefaultAllocatorDeinit(&alloc);- In
Int.Type.c:66:
IntDeinit(&original);
IntDeinit(&clone);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Type.c:98:
BitVecGet(&clone.bits, 0) == true && BitVecGet(&clone.bits, 1) == false && BitVecGet(&clone.bits, 2) == true;
IntDeinit(&original);
IntDeinit(&clone);
DefaultAllocatorDeinit(&alloc);- In
Int.Type.c:99:
IntDeinit(&original);
IntDeinit(&clone);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Type.c:128:
result = result && (IntBitLength(&sum) == 9);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&sum);- In
Int.Type.c:129:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&sum);
DefaultAllocatorDeinit(&alloc);- In
Int.Type.c:130:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&sum);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Type.c:151:
result = result && (IntToU64(&v255) == 255);
IntDeinit(&v255);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && IntEQ(&lhs, &rhs);
IntDeinit(&lhs);
IntDeinit(&rhs);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&lhs);
IntDeinit(&rhs);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (IntBitLength(&value) == 8);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && IntIsZero(&value);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && IntIsZero(&value);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && IntIsZero(&value);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && IntIsZero(&value);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && IntIsZero(&value);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&parsed);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (out == 0);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; Int value = IntInit(ALLOCATOR_OF(&alloc));
IntTryFromBinary(&value, (Zstr)NULL);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return false; Int value = IntInit(ALLOCATOR_OF(&alloc));
IntTryFromStr(&value, (Zstr)NULL);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return false; Int value = IntInit(ALLOCATOR_OF(&alloc));
IntTryFromStrRadix(&value, (Zstr)NULL, 10);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return false; Int value = IntInit(ALLOCATOR_OF(&alloc));
IntTryFromOctStr(&value, (Zstr)NULL);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return false; Int value = IntInit(ALLOCATOR_OF(&alloc));
IntTryFromHexStr(&value, (Zstr)NULL);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return false; result = result && (IntBitLength(&product) == 9);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&product);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&product);
DefaultAllocatorDeinit(&alloc); IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&product);
DefaultAllocatorDeinit(&alloc);
return result; result = result && IntIsZero(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; bool result = ok && (IntToU64(&value) == 7);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && IntIsZero(&invalid);
IntDeinit(&valid);
IntDeinit(&invalid);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&valid);
IntDeinit(&invalid);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&text);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result; StrDeinit(&hex_mid_u);
StrDeinit(&dec_big);
IntDeinit(&small);
IntDeinit(&mid);
IntDeinit(&big); StrDeinit(&dec_big);
IntDeinit(&small);
IntDeinit(&mid);
IntDeinit(&big);
DefaultAllocatorDeinit(&alloc); IntDeinit(&small);
IntDeinit(&mid);
IntDeinit(&big);
DefaultAllocatorDeinit(&alloc);
return result; StrDeinit(&back_dec);
StrDeinit(&back_hex);
IntDeinit(&parsed_dec);
IntDeinit(&parsed_hex);
DefaultAllocatorDeinit(&alloc); StrDeinit(&back_hex);
IntDeinit(&parsed_dec);
IntDeinit(&parsed_hex);
DefaultAllocatorDeinit(&alloc);
return result; bool result = parsed && (IntToU64(&out) == 395);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result; bool result = parsed && (IntToU64(&out) == 255);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result; bool result = parsed && (IntToU64(&out) == 123);
IntDeinit(&out);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc); bool result = parsed && (IntToU64(&out) == 5);
IntDeinit(&out);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc); result = result && (IntToU64(&value) == 123);
IntDeinit(&value);
StrDeinit(&digits);
DefaultAllocatorDeinit(&alloc); result = result && (IntToU64(&value) == 5);
IntDeinit(&value);
StrDeinit(&digits);
DefaultAllocatorDeinit(&alloc); result = result && (MemCompare(out, expect, 2) == 0);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (out[0] == 0x01);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (MemCompare(out, expect, 2) == 0);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (out[0] == 0x01);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (IntToU64(&out) == 5u);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (IntToU64(&out) == 42u);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result; bool result = ok && (IntToU64(&out) == 5);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result; bool result = ok && (IntToU64(&out) == 15);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result; bool result = ok && (IntToU64(&out) == 15);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return result; bool result = (ha != hb);
IntDeinit(&a);
IntDeinit(&b);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&a);
IntDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return result; bool fail = (IntCompare(&value, 0u) != 0);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return !fail; bool fail = (IntCompare(&value, 0x010203u) != 0);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return !fail; bool fail = parsed; // real code must reject this string.
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return !fail; fail = fail || (IntCompare(&out, 5u) != 0);
IntDeinit(&out);
DefaultAllocatorDeinit(&alloc);
return !fail; bool result = IntIsZero(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (IntBitLength(&value) == 3);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; bool result = (IntToU64(&value) == (u64)12345u);
IntDeinit(&value);
StrDeinit(&digits);
DefaultAllocatorDeinit(&alloc); bool result = (IntToU64(&value) == (u64)255u);
IntDeinit(&value);
StrDeinit(&digits);
DefaultAllocatorDeinit(&alloc);
StrDeinit(&hex);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;
StrDeinit(&hex);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (buf[1] == 0x02);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result; Int q = IntInit(a);
rem = int_div_u64_rem(&q, &v, 1000u);
IntDeinit(&q);
}
ok = ok && rem == 567u;
StrDeinit(&s);
IntDeinit(&v);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg); bool ok = IntToU64(&v) == 0x01020304u;
IntDeinit(&v);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg); ok = ok && IntToU64(&out) == 123456789u;
IntDeinit(&out);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);
StrDeinit(&hex);
IntDeinit(&value);
IntDeinit(&parsed); StrDeinit(&hex);
IntDeinit(&value);
IntDeinit(&parsed);
ok = ok && DebugAllocatorLiveCount(&dbg) == 0;- In
Io.Write.c:629:
success = success && (ZstrCompare(StrBegin(&output), " 123456789012345678901234567890") == 0);
IntDeinit(&big_dec);
IntDeinit(&hex_val);
IntDeinit(&bin_val);- In
Io.Write.c:630:
IntDeinit(&big_dec);
IntDeinit(&hex_val);
IntDeinit(&bin_val);
IntDeinit(&oct_val);- In
Io.Write.c:631:
IntDeinit(&big_dec);
IntDeinit(&hex_val);
IntDeinit(&bin_val);
IntDeinit(&oct_val);
StrDeinit(&output);- In
Io.Write.c:632:
IntDeinit(&hex_val);
IntDeinit(&bin_val);
IntDeinit(&oct_val);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Io.Write.c:3235:
success = (ZstrCompare(StrBegin(&output), "A") == 0);
IntDeinit(&a);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Io.Write.c:3254:
success = (ZstrCompare(StrBegin(&output), "z") == 0);
IntDeinit(&a);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Io.Write.c:3280:
success = (ZstrCompare(StrBegin(&output), " ab7") == 0);
IntDeinit(&seven);
StrDeinit(&output);
DefaultAllocatorDeinit(&alloc);- In
Io.Write.c:3829:
StrDeinit(&oct_text);
IntDeinit(&oct);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4410:
bool ok = (IntCompare(&v, 9) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4427:
bool ok = (IntCompare(&v, 5) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4443:
bool ok = (IntCompare(&v, 8) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4459:
bool ok = (IntCompare(&v, 123) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4476:
bool ok = (IntCompare(&v, 200) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4492:
bool ok = (IntCompare(&v, 200) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4507:
bool ok = (IntCompare(&v, 255) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4522:
bool ok = (IntCompare(&v, 5) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4536:
bool ok = (IntCompare(&v, 5) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4550:
bool ok = (IntCompare(&v, 5) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4565:
bool ok = (IntCompare(&v, 9) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4579:
bool ok = (IntCompare(&v, 9) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4593:
bool ok = (IntCompare(&v, 15) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:4608:
bool ok = (IntCompare(&v, 42) == 0);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Write.c:5440:
StrAppendFmt(&out, "{}", v);
bool ok = (ZstrCompare(StrBegin(&out), "123456789012345678901234567890") == 0);
IntDeinit(&v);
return ok && dbg_no_leak(&dbg, &out);
}- In
Io.Write.c:5455:
StrAppendFmt(&out, "{6}", v);
ok = ok && (ZstrCompare(StrBegin(&out), " 42") == 0);
IntDeinit(&v);
StrDeinit(&out);
DefaultAllocatorDeinit(&alloc);- In
Io.Write.c:5695:
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0) && (DebugAllocatorLiveBytes(&dbg) == 0);
DebugAllocatorDeinit(&dbg);
IntDeinit(&v);
HeapAllocatorDeinit(&va);
return ok; FloatDeinit(&value);
FloatDeinit(&same);
IntDeinit(&whole);
IntDeinit(&next);
DefaultAllocatorDeinit(&alloc); FloatDeinit(&same);
IntDeinit(&whole);
IntDeinit(&next);
DefaultAllocatorDeinit(&alloc);
return result; ok = ok && (c3 == 0) && (err == false);
IntDeinit(&i3);
FloatDeinit(&v);
DefaultAllocatorDeinit(&alloc);
FloatDeinit(&lhs);
IntDeinit(&less);
IntDeinit(&same);
IntDeinit(&more); FloatDeinit(&lhs);
IntDeinit(&less);
IntDeinit(&same);
IntDeinit(&more);
DefaultAllocatorDeinit(&alloc); IntDeinit(&less);
IntDeinit(&same);
IntDeinit(&more);
DefaultAllocatorDeinit(&alloc);
return ok;
FloatDeinit(&a);
IntDeinit(&b);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Compare.c:34:
result = result && (IntCompare(&b, &c) == 0);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);- In
Int.Compare.c:35:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);
DefaultAllocatorDeinit(&alloc);- In
Int.Compare.c:36:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Compare.c:59:
result = result && IntNE(&a, &b);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);- In
Int.Compare.c:60:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);
DefaultAllocatorDeinit(&alloc);- In
Int.Compare.c:61:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Compare.c:89:
result = result && IntNE(&value, 43);
IntDeinit(&value);
IntDeinit(&same);
IntDeinit(&big);- In
Int.Compare.c:90:
IntDeinit(&value);
IntDeinit(&same);
IntDeinit(&big);
DefaultAllocatorDeinit(&alloc);- In
Int.Compare.c:91:
IntDeinit(&value);
IntDeinit(&same);
IntDeinit(&big);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (int_hash(&c, 0) == int_hash(&d, 0));
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);
IntDeinit(&d); IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&c);
IntDeinit(&d);
DefaultAllocatorDeinit(&alloc); IntDeinit(&b);
IntDeinit(&c);
IntDeinit(&d);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (h_zero != h_decimal);
IntDeinit(&zero);
IntDeinit(&one);
IntDeinit(&small);
IntDeinit(&zero);
IntDeinit(&one);
IntDeinit(&small);
IntDeinit(&large); IntDeinit(&zero);
IntDeinit(&one);
IntDeinit(&small);
IntDeinit(&large);
IntDeinit(&decimal); IntDeinit(&one);
IntDeinit(&small);
IntDeinit(&large);
IntDeinit(&decimal);
DefaultAllocatorDeinit(&alloc); IntDeinit(&small);
IntDeinit(&large);
IntDeinit(&decimal);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (MapPairCount(&counts) == 2);
IntDeinit(&k1);
IntDeinit(&k2);
IntDeinit(&k3);
IntDeinit(&k1);
IntDeinit(&k2);
IntDeinit(&k3);
IntDeinit(&probe); IntDeinit(&k1);
IntDeinit(&k2);
IntDeinit(&k3);
IntDeinit(&probe);
IntDeinit(&missing); IntDeinit(&k2);
IntDeinit(&k3);
IntDeinit(&probe);
IntDeinit(&missing);
MapDeinit(&counts); IntDeinit(&k3);
IntDeinit(&probe);
IntDeinit(&missing);
MapDeinit(&counts);
DefaultAllocatorDeinit(&alloc); fail = fail || (IntCompare(&lhs, 0x8000000000000000u) != 0);
IntDeinit(&lhs);
DefaultAllocatorDeinit(&alloc);
return !fail; bool fail = (IntCompare(&lhs, 9u) != -1);
IntDeinit(&lhs);
DefaultAllocatorDeinit(&alloc);
return !fail; bool result = (IntIsOne(&one) == true);
IntDeinit(&one);
DefaultAllocatorDeinit(&alloc);
return result; result = result && (int_compare_i64(&five, (i64)0) > 0);
IntDeinit(&five);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);
IntDeinit(&five);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);
return result; bool result = ZstrCompare(StrBegin(&text), "12345678901234567890") == 0;
IntDeinit(&integer);
StrDeinit(&text);
FloatDeinit(&value);
FloatDeinit(&value);
IntDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);
FloatDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;
FloatDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result; bool result = FloatExponent(&value) == 2;
IntDeinit(&whole);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);
StrDeinit(&text);
IntDeinit(&whole);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);
StrDeinit(&text);
IntDeinit(&whole);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc); result = result && (FloatCompare(&value, &whole) == 0);
IntDeinit(&whole);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);
FloatDeinit(&v);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);
FloatDeinit(&v);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);
FloatDeinit(&v);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);
FloatDeinit(&v);
IntDeinit(&r);
bool ok = LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);
FloatDeinit(&v);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Float.Math.c:183:
FloatDeinit(&a);
FloatDeinit(&b);
IntDeinit(&whole);
FloatDeinit(&result_value);
StrDeinit(&text);- In
Float.Math.c:273:
FloatDeinit(&a);
FloatDeinit(&b);
IntDeinit(&whole);
FloatDeinit(&result_value);
StrDeinit(&text);- In
Float.Math.c:363:
FloatDeinit(&a);
FloatDeinit(&b);
IntDeinit(&whole);
FloatDeinit(&result_value);
StrDeinit(&text);- In
Float.Math.c:458:
FloatDeinit(&a);
FloatDeinit(&b);
IntDeinit(&whole);
FloatDeinit(&result_value);
StrDeinit(&text);- In
Float.Math.c:807:
bool pass = (ok == false);
IntDeinit(&zero);
FloatDeinit(&a);
FloatDeinit(&result); FloatDeinit(&a);
FloatDeinit(&r);
IntDeinit(&b);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg); FloatDeinit(&a);
FloatDeinit(&r);
IntDeinit(&b);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg); FloatDeinit(&a);
FloatDeinit(&r);
IntDeinit(&b);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg); FloatDeinit(&a);
FloatDeinit(&r);
IntDeinit(&b);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Float.Type.c:179:
bool ok = (FloatToInt(&out, &neg) == false);
IntDeinit(&out);
FloatDeinit(&neg);
DefaultAllocatorDeinit(&alloc);- In
Float.Type.c:215:
StrDeinit(&text);
IntDeinit(&result);
IntDeinit(&value.significand);
DefaultAllocatorDeinit(&alloc);- In
Float.Type.c:216:
StrDeinit(&text);
IntDeinit(&result);
IntDeinit(&value.significand);
DefaultAllocatorDeinit(&alloc);
return right;- In
Float.Type.c:236:
StrDeinit(&text);
IntDeinit(&result);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Float.Type.c:254:
bool right = ok && IntIsZero(&result);
IntDeinit(&result);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Float.Type.c:272:
bool right = (ok == false);
IntDeinit(&result);
FloatDeinit(&value);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:36:
bool result = IntBitLength(&value) == 6;
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:50:
bool result = IntByteLength(&value) == 2;
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:66:
result = result && !IntIsZero(&non_zero);
IntDeinit(&zero);
IntDeinit(&non_zero);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:67:
IntDeinit(&zero);
IntDeinit(&non_zero);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:83:
result = result && !IntIsOne(&two);
IntDeinit(&one);
IntDeinit(&two);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:84:
IntDeinit(&one);
IntDeinit(&two);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:102:
result = result && !IntIsEven(&odd);
IntDeinit(&even);
IntDeinit(&odd);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:103:
IntDeinit(&even);
IntDeinit(&odd);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:121:
result = result && !IntFitsU64(&big);
IntDeinit(&small);
IntDeinit(&big);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:122:
IntDeinit(&small);
IntDeinit(&big);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:138:
result = result && !error;
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:154:
result = result && (IntTrailingZeroCount(&zero) == 0);
IntDeinit(&value);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:155:
IntDeinit(&value);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:177:
result = result && !IntIsPowerOfTwo(&zero);
IntDeinit(&one);
IntDeinit(&power);
IntDeinit(&other);- In
Int.Access.c:178:
IntDeinit(&one);
IntDeinit(&power);
IntDeinit(&other);
IntDeinit(&zero);- In
Int.Access.c:179:
IntDeinit(&one);
IntDeinit(&power);
IntDeinit(&other);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:180:
IntDeinit(&power);
IntDeinit(&other);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:196:
result = result && error;
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:219:
result = result && (IntCompare(&remainder, 0) == 0);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Access.c:220:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:221:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:239:
bool result = (h == 1469598103934665603ULL);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:262:
bool result = (h == expected);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:280:
bool result = ok && (IntToU64(&value) == 5);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:304:
fail = fail || (IntCompare(&value, 7u) != 0); // value preserved.
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return !fail;- In
Int.Access.c:324:
result = result && (IntTrailingZeroCount(&value) == 3u);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Access.c:363:
bool result = ok && (IntToU64(&result_value) == 3);
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Access.c:364:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Access.c:365:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:84:
result = result && (IntBitLength(&value) == 6);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:101:
result = result && (IntBitLength(&value) == 2);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:123:
StrDeinit(&text);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:124:
StrDeinit(&text);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:125:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:154:
result = result && (ZstrCompare(StrBegin(&text), "123456789012345678901234567900") == 0);
IntDeinit(&base);
IntDeinit(&rhs);
IntDeinit(&result_value);- In
Int.Math.c:155:
IntDeinit(&base);
IntDeinit(&rhs);
IntDeinit(&result_value);
IntDeinit(&huge);- In
Int.Math.c:156:
IntDeinit(&base);
IntDeinit(&rhs);
IntDeinit(&result_value);
IntDeinit(&huge);
StrDeinit(&text);- In
Int.Math.c:157:
IntDeinit(&rhs);
IntDeinit(&result_value);
IntDeinit(&huge);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:175:
result = result && (IntToU64(&result_value) == 255);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:176:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:177:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:210:
result = result && (IntToU64(&preserved) == 99);
IntDeinit(&base);
IntDeinit(&rhs);
IntDeinit(&result_value);- In
Int.Math.c:211:
IntDeinit(&base);
IntDeinit(&rhs);
IntDeinit(&result_value);
IntDeinit(&preserved);- In
Int.Math.c:212:
IntDeinit(&base);
IntDeinit(&rhs);
IntDeinit(&result_value);
IntDeinit(&preserved);
IntDeinit(&huge);- In
Int.Math.c:213:
IntDeinit(&rhs);
IntDeinit(&result_value);
IntDeinit(&preserved);
IntDeinit(&huge);
StrDeinit(&text);- In
Int.Math.c:214:
IntDeinit(&result_value);
IntDeinit(&preserved);
IntDeinit(&huge);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:232:
result = result && (IntToU64(&result_value) == 99);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:233:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:234:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:252:
bool result = IntToU64(&result_value) == 126;
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:253:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:254:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:273:
bool result = ZstrCompare(StrBegin(&text), "308641972530864197250") == 0;
IntDeinit(&value);
IntDeinit(&result_value);
StrDeinit(&text);- In
Int.Math.c:274:
IntDeinit(&value);
IntDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:294:
result = result && (IntToU64(&result_value) == 0);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:295:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:296:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:313:
bool result = IntToU64(&result_value) == 152399025;
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:314:
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:338:
result = result && (ZstrCompare(StrBegin(&text), "79792266297612001") == 0);
IntDeinit(&base);
IntDeinit(&exponent);
IntDeinit(&result_value);- In
Int.Math.c:339:
IntDeinit(&base);
IntDeinit(&exponent);
IntDeinit(&result_value);
StrDeinit(&text);- In
Int.Math.c:340:
IntDeinit(&base);
IntDeinit(&exponent);
IntDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:363:
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:364:
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:365:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:382:
bool result = IntToU64(&result_value) == 12;
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:383:
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:401:
result = result && (ZstrCompare(StrBegin(&text), "137174210013717421") == 0);
IntDeinit(÷nd);
IntDeinit(&result_value);
StrDeinit(&text);- In
Int.Math.c:402:
IntDeinit(÷nd);
IntDeinit(&result_value);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:420:
result = result && (IntToU64(&result_value) == 99);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit(&result_value);- In
Int.Math.c:421:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:422:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:443:
result = result && (IntToU64(&remainder) == 3);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:444:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
StrDeinit(&text);- In
Int.Math.c:445:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:463:
bool result = IntToU64(&result_value) == 6;
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:464:
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:479:
IntMod(&remainder, &value, 97u);
IntDeinit(&value);
bool result = IntToU64(&remainder) == 3;
IntDeinit(&remainder);- In
Int.Math.c:481:
IntDeinit(&value);
bool result = IntToU64(&remainder) == 3;
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:499:
bool result = IntToU64(&result_value) == 6;
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:500:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:501:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:519:
bool result = IntToU64(&result_value) == 42;
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:520:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:521:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:538:
bool result = IntToU64(&result_value) == 8;
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:539:
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:558:
result = result && (IntToU64(&remainder) == 75);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:559:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:560:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:577:
bool result = IntToU64(&result_value) == 14;
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:578:
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:597:
result = result && (IntToU64(&remainder) == 4);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:598:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:599:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:615:
result = result && !IntIsPerfectSquare(&non_square);
IntDeinit(&square);
IntDeinit(&non_square);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:616:
IntDeinit(&square);
IntDeinit(&non_square);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:634:
result = result && IntIsPerfectPower(&one);
IntDeinit(&power);
IntDeinit(&non_power);
IntDeinit(&one);- In
Int.Math.c:635:
IntDeinit(&power);
IntDeinit(&non_power);
IntDeinit(&one);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:636:
IntDeinit(&power);
IntDeinit(&non_power);
IntDeinit(&one);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:654:
result = result && (IntJacobi(&b, &n) == 0);
IntDeinit(&a);
IntDeinit(&p);
IntDeinit(&b);- In
Int.Math.c:655:
IntDeinit(&a);
IntDeinit(&p);
IntDeinit(&b);
IntDeinit(&n);- In
Int.Math.c:656:
IntDeinit(&a);
IntDeinit(&p);
IntDeinit(&b);
IntDeinit(&n);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:657:
IntDeinit(&p);
IntDeinit(&b);
IntDeinit(&n);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:675:
bool result = IntToU64(&result_value) == 94;
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:676:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:677:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:696:
bool result = IntToU64(&result_value) == 12;
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);- In
Int.Math.c:697:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);- In
Int.Math.c:698:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:699:
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:718:
bool result = IntToU64(&result_value) == 9;
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);- In
Int.Math.c:719:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);- In
Int.Math.c:720:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:721:
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:740:
bool result = IntToU64(&result_value) == 22;
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);- In
Int.Math.c:741:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);- In
Int.Math.c:742:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:743:
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:765:
result = result && (IntCompare(&check, 10) == 0);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);- In
Int.Math.c:766:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);- In
Int.Math.c:767:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
IntDeinit(&check);- In
Int.Math.c:768:
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:769:
IntDeinit(&m);
IntDeinit(&result_value);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:787:
bool result = IntToU64(&result_value) == 3;
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:788:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:789:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:808:
bool result = IntToU64(&result_value) == 445;
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);- In
Int.Math.c:809:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:810:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:811:
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:832:
result = result && (IntToU64(&check) == 1);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:833:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);
IntDeinit(&check);- In
Int.Math.c:834:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:835:
IntDeinit(&mod);
IntDeinit(&result_value);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:854:
result = result && (IntCompare(&check, 10) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:855:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:856:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:857:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:874:
result = result && (IntCompare(&root, 99) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:875:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:876:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:892:
result = result && !IntIsProbablePrime(&composite);
IntDeinit(&prime);
IntDeinit(&composite);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:893:
IntDeinit(&prime);
IntDeinit(&composite);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:912:
bool result = ok && ZstrCompare(StrBegin(&text), "1000000007") == 0;
IntDeinit(&value);
IntDeinit(&next);
StrDeinit(&text);- In
Int.Math.c:913:
IntDeinit(&value);
IntDeinit(&next);
StrDeinit(&text);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:931:
result = result && (IntToU64(&result_value) == 99);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:932:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:933:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:951:
result = result && (IntCompare(&result_value, 99) == 0);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);- In
Int.Math.c:952:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);- In
Int.Math.c:953:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:954:
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:997:
result = result && (IntCompare(&remainder, 77) == 0);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);- In
Int.Math.c:998:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:999:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1000:
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1018:
result = result && (IntCompare(&remainder, 77) == 0);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:1019:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1020:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1036:
bool result = IntCompare("ient, 99) == 0;
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1037:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1053:
bool result = IntCompare(&result_value, 99) == 0;
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1054:
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1072:
result = result && (IntCompare(&result_value, 99) == 0);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);- In
Int.Math.c:1073:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);- In
Int.Math.c:1074:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1075:
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1095:
result = result && error;
IntDeinit(&a);
IntDeinit(&n);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1096:
IntDeinit(&a);
IntDeinit(&n);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1128:
result = result && (IntCompare(&result_value, 99) == 0);
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);- In
Int.Math.c:1129:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:1130:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1131:
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1163:
result = result && (IntCompare(&root, 99) != 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1164:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:1165:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1166:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1185:
result = result && (IntCompare(&root, 99) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1186:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1187:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1217:
result = result && (IntCompare(&root, 99) != 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1218:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:1219:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1220:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1246:
result = result && (IntCompare(&root, 0) >= 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1247:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:1248:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1249:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1277:
result = result && (IntCompare(&root, 99) != 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1278:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:1279:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1280:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1305:
result = result && (IntCompare(&root, 0) >= 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1306:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:1307:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1308:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1330:
result = result && (IntCompare(&root, 13) < 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1331:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:1332:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1333:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1352:
result = result && (IntCompare(&root, 99) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1353:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1354:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1376:
result = result && (IntCompare(&root, 0) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1377:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1378:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1398:
result = result && (IntCompare(&root, 0) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1399:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1400:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1422:
result = result && (IntCompare(&root, 1) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1423:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1424:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1445:
result = result && (IntCompare(&root, 99) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1446:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1447:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1466:
result = result && (IntCompare(&root, 99) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1467:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1468:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1488:
result = result && (IntCompare(&root, 99) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1489:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1490:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1517:
result = result && (IntCompare(&root, 7) < 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:1518:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:1519:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1520:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1545:
bool result = ok && (IntToU64(&product) == (u64)121932631112635269ull);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&product);- In
Int.Math.c:1546:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&product);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1547:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&product);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1572:
result = result && (IntBitLength(&product) == 0u);
IntDeinit(&a);
IntDeinit(&zero);
IntDeinit(&product);- In
Int.Math.c:1573:
IntDeinit(&a);
IntDeinit(&zero);
IntDeinit(&product);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1574:
IntDeinit(&a);
IntDeinit(&zero);
IntDeinit(&product);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1623:
ok = ok && (IntToU64(&result) == 16807);
IntDeinit(&base);
IntDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1624:
IntDeinit(&base);
IntDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Int.Math.c:1645:
IntGCD(NULL, &a, &b);
IntDeinit(&a);
IntDeinit(&b);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1646:
IntDeinit(&a);
IntDeinit(&b);
DefaultAllocatorDeinit(&alloc);
return false;- In
Int.Math.c:1669:
IntGCD(&result, NULL, &b);
IntDeinit(&b);
IntDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1670:
IntDeinit(&b);
IntDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return false;- In
Int.Math.c:1690:
IntGCD(&result, &a, NULL);
IntDeinit(&a);
IntDeinit(&result);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1691:
IntDeinit(&a);
IntDeinit(&result);
DefaultAllocatorDeinit(&alloc);
return false;- In
Int.Math.c:1714:
IntModAdd(NULL, &a, &b, &m);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);- In
Int.Math.c:1715:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1716:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
DefaultAllocatorDeinit(&alloc);
return false;- In
Int.Math.c:1768:
ok = ok && (IntToU64(&result_value) == 3);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:1769:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1770:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Int.Math.c:1826:
int_div_u64_rem("ient, NULL, 7);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return false;- In
Int.Math.c:1851:
result = result && (IntCompare(&result_value, 0) == 0);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);- In
Int.Math.c:1852:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1853:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1883:
result = result && IntIsPerfectPower(&square_anchor);
IntDeinit(&boundary);
IntDeinit(&square_anchor);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1884:
IntDeinit(&boundary);
IntDeinit(&square_anchor);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1910:
IntDivExact(NULL, ÷nd, &divisor);
IntDeinit(÷nd);
IntDeinit(&divisor);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1911:
IntDeinit(÷nd);
IntDeinit(&divisor);
DefaultAllocatorDeinit(&alloc);
return false;- In
Int.Math.c:1936:
StrDeinit(&bits);
IntDeinit(&ones);
IntDeinit(&one);
IntDeinit(&sum);- In
Int.Math.c:1937:
StrDeinit(&bits);
IntDeinit(&ones);
IntDeinit(&one);
IntDeinit(&sum);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1938:
IntDeinit(&ones);
IntDeinit(&one);
IntDeinit(&sum);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1960:
result = result && (IntCompare(&remainder, 0) == 0);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:1961:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1962:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:1985:
result = result && (IntToU64(&remainder) == 0);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:1986:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:1987:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2008:
result = result && (IntToU64(&remainder) == 0);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:2009:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2010:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2032:
result = result && (IntToU64(&remainder) == 1);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:2033:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2034:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2055:
result = result && (IntToU64(&remainder) == 270);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:2056:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2057:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2078:
result = result && (IntToU64(&remainder) == 76479);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:2079:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2080:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2109:
result = result && (IntToU64(&power) == 16807u);
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&power);- In
Int.Math.c:2110:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&power);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2111:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&power);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2136:
bool result = rejected && (IntCompare(&power, &sentinel) == 0);
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&power);- In
Int.Math.c:2137:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&power);
IntDeinit(&sentinel);- In
Int.Math.c:2138:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&power);
IntDeinit(&sentinel);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2139:
IntDeinit(&exp);
IntDeinit(&power);
IntDeinit(&sentinel);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2166:
result = result && (IntToU64("ient) == 142u);
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2167:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2187:
bool result = failed;
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2188:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2212:
result = result && (IntToU64("ient) == 143u);
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2213:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2231:
bool result = failed;
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2232:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2261:
fail = fail || (IntBitLength(&value) != 3);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return !fail;- In
Int.Math.c:2279:
fail = fail || (IntBitLength(&value) != 1);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return !fail;- In
Int.Math.c:2305:
bool result = ok && (IntToU64(&result_value) == 91);
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2306:
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2329:
bool result = ok && (IntToU64(&result_value) == 0);
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2330:
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2354:
bool result = ok && (IntToU64(&result_value) == 81);
IntDeinit(&base);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2355:
IntDeinit(&base);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2378:
bool result = ok && (IntToU64(&result_value) == 1);
IntDeinit(&base);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2379:
IntDeinit(&base);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2403:
bool result = ok && (IntToU64(&result_value) == 14);
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2404:
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2428:
result = result && (IntToU64(&result_value) == 41152263u);
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2429:
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2457:
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:2458:
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2459:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2487:
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:2488:
StrDeinit(&qtext);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2489:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2514:
result = result && (IntToU64(&result_value) == 1u);
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2515:
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2542:
result = result && (IntToU64(&result_value) == 889009735u);
IntDeinit(&base);
IntDeinit(&modulus);
IntDeinit(&result_value);- In
Int.Math.c:2543:
IntDeinit(&base);
IntDeinit(&modulus);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2544:
IntDeinit(&base);
IntDeinit(&modulus);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2569:
result = result && (IntToU64(&result_value) == 1u);
IntDeinit(&base);
IntDeinit(&modulus);
IntDeinit(&result_value);- In
Int.Math.c:2570:
IntDeinit(&base);
IntDeinit(&modulus);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2571:
IntDeinit(&base);
IntDeinit(&modulus);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2593:
result = result && (IntToU64(&result_value) == 8u);
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2594:
IntDeinit(&value);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2616:
bool result = (IntIsOdd(&zero) == false);
IntDeinit(&zero);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2639:
bool correct = ok && (IntToU64(&result) == (u64)2u);
IntDeinit(&result);
IntDeinit(÷nd);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2640:
IntDeinit(&result);
IntDeinit(÷nd);
DefaultAllocatorDeinit(&alloc);
return correct;- In
Int.Math.c:2687:
result = result && (err_bad == true);
IntDeinit(&a);
IntDeinit(&n_odd);
IntDeinit(&n_even);- In
Int.Math.c:2688:
IntDeinit(&a);
IntDeinit(&n_odd);
IntDeinit(&n_even);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2689:
IntDeinit(&a);
IntDeinit(&n_odd);
IntDeinit(&n_even);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2723:
pass = pass && (IntToU64(&check) == 1);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result);- In
Int.Math.c:2724:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result);
IntDeinit(&check);- In
Int.Math.c:2725:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2726:
IntDeinit(&mod);
IntDeinit(&result);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Int.Math.c:2755:
pass = pass && (IntToU64(&check) == 1);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result);- In
Int.Math.c:2756:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result);
IntDeinit(&check);- In
Int.Math.c:2757:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&result);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2758:
IntDeinit(&mod);
IntDeinit(&result);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return pass;- In
Int.Math.c:2781:
result = result && (IntCompare("ient, 99) == 0);
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2782:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2799:
result = result && (IntCompare("ient, 99) == 0);
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2800:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2820:
bool result = (ok == false);
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2821:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2837:
bool result = (ok == false);
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2838:
IntDeinit(÷nd);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2858:
bool result = (ok == false);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:2859:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2860:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2877:
bool result = (ok == false);
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:2878:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2879:
IntDeinit(÷nd);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2898:
bool result = (ok == false);
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2899:
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2915:
bool result = (ok == false);
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2916:
IntDeinit(÷nd);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2942:
result = result && (IntToU64(&remainder) == 0);
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);- In
Int.Math.c:2943:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2944:
IntDeinit(&value);
IntDeinit(&root);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2965:
bool result = ok && (symbol == -1);
IntDeinit(&a);
IntDeinit(&n);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2966:
IntDeinit(&a);
IntDeinit(&n);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:2991:
bool result = ok && (IntCompare(&check, 2) == 0);
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);- In
Int.Math.c:2992:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:2993:
IntDeinit(&value);
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:2994:
IntDeinit(&mod);
IntDeinit(&root);
IntDeinit(&check);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3008:
bool result = !IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3022:
bool result = IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3036:
bool result = !IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3050:
bool result = IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3064:
bool result = IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3078:
bool result = !IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3092:
bool result = !IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3106:
bool result = !IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3120:
bool result = IntIsProbablePrime(&value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3136:
bool result = prime && !error;
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3168:
StrDeinit(&qtext);
StrDeinit(&rtext);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);- In
Int.Math.c:3169:
StrDeinit(&rtext);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:3170:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3171:
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3198:
result = result && (IntToU64(&remainder) == 41u);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);- In
Int.Math.c:3199:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:3200:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3201:
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3227:
result = result && IntIsZero(&remainder);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);- In
Int.Math.c:3228:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:3229:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3230:
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3255:
result = result && (IntToU64(&remainder) == 42u);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);- In
Int.Math.c:3256:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:3257:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3258:
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3281:
bool result = (ok == false);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);- In
Int.Math.c:3282:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);- In
Int.Math.c:3283:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3284:
IntDeinit(&divisor);
IntDeinit("ient);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3304:
int_div_mod(NULL, &remainder, ÷nd, &divisor);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit(&remainder);- In
Int.Math.c:3305:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3306:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit(&remainder);
DefaultAllocatorDeinit(&alloc);
return true;- In
Int.Math.c:3326:
int_div_mod("ient, NULL, ÷nd, &divisor);
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);- In
Int.Math.c:3327:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3328:
IntDeinit(÷nd);
IntDeinit(&divisor);
IntDeinit("ient);
DefaultAllocatorDeinit(&alloc);
return true;- In
Int.Math.c:3346:
ok = ok && (IntCompare(&result_value, 0) == 0);
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);- In
Int.Math.c:3347:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:3348:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3349:
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Int.Math.c:3367:
ok = ok && (IntCompare(&result_value, 0) == 0);
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);- In
Int.Math.c:3368:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:3369:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3370:
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Int.Math.c:3388:
ok = ok && (IntToU64(&result_value) == 444);
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);- In
Int.Math.c:3389:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:3390:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3391:
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Int.Math.c:3408:
bool ok = int_pow_mod(&result_value, &base, &exp, &mod);
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);- In
Int.Math.c:3409:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:3410:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:3411:
IntDeinit(&exp);
IntDeinit(&mod);
IntDeinit(&result_value);
// After releasing every Int the test created, nothing the function
- In
Int.Math.c:3440:
bool result = ok && (IntToU64(&next) == 2);
IntDeinit(&value);
IntDeinit(&next);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3441:
IntDeinit(&value);
IntDeinit(&next);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3468:
bool result = ok && (IntToU64(&next) == 11);
IntDeinit(&value);
IntDeinit(&next);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3469:
IntDeinit(&value);
IntDeinit(&next);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3491:
bool result = ok && (IntToU64(&next) == 11);
IntDeinit(&value);
IntDeinit(&next);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3492:
IntDeinit(&value);
IntDeinit(&next);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3512:
(void)IntNextPrime(NULL, &value);
IntDeinit(&value);
DefaultAllocatorDeinit(&alloc);
return true;- In
Int.Math.c:3535:
ok = ok && (IntToU64(&result_value) == 4);
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);- In
Int.Math.c:3536:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);- In
Int.Math.c:3537:
IntDeinit(&a);
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3538:
IntDeinit(&b);
IntDeinit(&m);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Int.Math.c:3582:
bool result = ok && (IntToU64(&result_value) == 12);
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:3583:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3584:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3604:
bool result = ok && (IntToU64(&result_value) == 1);
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:3605:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3606:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3628:
bool result = ok && (IntToU64(&result_value) == 582344008);
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);- In
Int.Math.c:3629:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);- In
Int.Math.c:3630:
IntDeinit(&base);
IntDeinit(&mod);
IntDeinit(&result_value);
DefaultAllocatorDeinit(&alloc);
return result;- In
Int.Math.c:3691:
ok = ok && IntToU64(&r) == 123456ull * 7891011ull;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);- In
Int.Math.c:3692:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3693:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3710:
ok = ok && IntIsZero(&r);
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);- In
Int.Math.c:3711:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3712:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3729:
ok = ok && IntToU64(&r) == 0xFFFFFFFFull + 0xFFFFFFFFull;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);- In
Int.Math.c:3730:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3731:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3748:
ok = ok && IntToU64(&r) == 17u;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);- In
Int.Math.c:3749:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3750:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3768:
ok = ok && IntToU64(&r) == 750u;
IntDeinit(&x);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3769:
IntDeinit(&x);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3787:
ok = ok && IntToU64(&r) == 6500u;
IntDeinit(&x);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3788:
IntDeinit(&x);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3804:
ok = ok && IntToU64(&r) == 750u;
IntDeinit(&x);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3805:
IntDeinit(&x);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3825:
ok = ok && IntToU64(&q) == 1000003u / 101u && IntToU64(&r) == 1000003u % 101u;
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&q);- In
Int.Math.c:3826:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&q);
IntDeinit(&r);- In
Int.Math.c:3827:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&q);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3828:
IntDeinit(&dvs);
IntDeinit(&q);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3847:
ok = ok && IntIsZero(&q) && IntToU64(&r) == 50u;
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&q);- In
Int.Math.c:3848:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&q);
IntDeinit(&r);- In
Int.Math.c:3849:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&q);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3850:
IntDeinit(&dvs);
IntDeinit(&q);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3867:
ok = ok && IntToU64(&r) == 1000003u / 101u;
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);- In
Int.Math.c:3868:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3869:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3886:
ok = ok && IntToU64(&r) == 125u;
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);- In
Int.Math.c:3887:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3888:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3910:
ok = ok && IntToU64(&r1) == 125u && IntToU64(&r2) == 125u && IntToU64(&r3) == 125u;
IntDeinit(&dvd);
IntDeinit(&r1);
IntDeinit(&r2);- In
Int.Math.c:3911:
IntDeinit(&dvd);
IntDeinit(&r1);
IntDeinit(&r2);
IntDeinit(&r3);- In
Int.Math.c:3912:
IntDeinit(&dvd);
IntDeinit(&r1);
IntDeinit(&r2);
IntDeinit(&r3);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3913:
IntDeinit(&r1);
IntDeinit(&r2);
IntDeinit(&r3);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3937:
ok = ok && IntToU64(&m1) == 3u && IntToU64(&m2) == 3u;
IntDeinit(&dvd);
IntDeinit(&q);
IntDeinit(&r);- In
Int.Math.c:3938:
IntDeinit(&dvd);
IntDeinit(&q);
IntDeinit(&r);
IntDeinit(&m1);- In
Int.Math.c:3939:
IntDeinit(&dvd);
IntDeinit(&q);
IntDeinit(&r);
IntDeinit(&m1);
IntDeinit(&m2);- In
Int.Math.c:3940:
IntDeinit(&q);
IntDeinit(&r);
IntDeinit(&m1);
IntDeinit(&m2);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3941:
IntDeinit(&r);
IntDeinit(&m1);
IntDeinit(&m2);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3958:
ok = ok && IntToU64(&r) == 3u;
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);- In
Int.Math.c:3959:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3960:
IntDeinit(&dvd);
IntDeinit(&dvs);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3978:
ok = ok && IntToU64(&r) == 1594323u; // 3^13
IntDeinit(&base);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3979:
IntDeinit(&base);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:3997:
ok = ok && IntToU64(&r) == 6u;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);- In
Int.Math.c:3998:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:3999:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4017:
ok = ok && IntToU64(&r) == 42u;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);- In
Int.Math.c:4018:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4019:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4038:
ok = ok && IntToU64(&root) == 100u && IntIsZero(&rem);
IntDeinit(&v);
IntDeinit(&root);
IntDeinit(&rem);- In
Int.Math.c:4039:
IntDeinit(&v);
IntDeinit(&root);
IntDeinit(&rem);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4040:
IntDeinit(&v);
IntDeinit(&root);
IntDeinit(&rem);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4063:
ok = ok && IntToU64(&root) == 9u && IntToU64(&rem) == 999u - 729u;
IntDeinit(&v);
IntDeinit(&v2);
IntDeinit(&root);- In
Int.Math.c:4064:
IntDeinit(&v);
IntDeinit(&v2);
IntDeinit(&root);
IntDeinit(&rem);- In
Int.Math.c:4065:
IntDeinit(&v);
IntDeinit(&v2);
IntDeinit(&root);
IntDeinit(&rem);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4066:
IntDeinit(&v2);
IntDeinit(&root);
IntDeinit(&rem);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4082:
ok = ok && IntToU64(&r) == 100u;
IntDeinit(&v);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4083:
IntDeinit(&v);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4099:
bool ok = IntIsPerfectSquare(&sq) && !IntIsPerfectSquare(&nsq);
IntDeinit(&sq);
IntDeinit(&nsq);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4100:
IntDeinit(&sq);
IntDeinit(&nsq);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4116:
bool ok = IntIsPerfectPower(&pw) && !IntIsPerfectPower(&npw);
IntDeinit(&pw);
IntDeinit(&npw);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4117:
IntDeinit(&pw);
IntDeinit(&npw);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4141:
ok = ok && IntTryJacobi(&jr2, &x2, &n2) && jr2 == 0;
IntDeinit(&x);
IntDeinit(&n);
IntDeinit(&x2);- In
Int.Math.c:4142:
IntDeinit(&x);
IntDeinit(&n);
IntDeinit(&x2);
IntDeinit(&n2);- In
Int.Math.c:4143:
IntDeinit(&x);
IntDeinit(&n);
IntDeinit(&x2);
IntDeinit(&n2);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4144:
IntDeinit(&n);
IntDeinit(&x2);
IntDeinit(&n2);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4162:
ok = ok && IntToU64(&r) == (12345u % 1009u + 67890u % 1009u) % 1009u;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);- In
Int.Math.c:4163:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4164:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4165:
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4184:
ok = ok && IntToU64(&r) == 800u;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);- In
Int.Math.c:4185:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4186:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4187:
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4206:
ok = ok && IntToU64(&r) == 1009u - 800u;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);- In
Int.Math.c:4207:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4208:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4209:
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4233:
ok = ok && IntIsZero(&r);
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);- In
Int.Math.c:4234:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4235:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4236:
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4254:
ok = ok && IntToU64(&r) == (12345ull * 67890ull) % 1009ull;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);- In
Int.Math.c:4255:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4256:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4257:
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4274:
ok = ok && IntToU64(&r) == (12345ull * 12345ull) % 1009ull;
IntDeinit(&x);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4275:
IntDeinit(&x);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4276:
IntDeinit(&x);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4294:
bool ok = IntModDiv(&r, &x, &y, &m);
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);- In
Int.Math.c:4295:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4296:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4297:
IntDeinit(&y);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4316:
ok = ok && IntToU64(&r) == 96889010407ull % 1000000007ull; // 7^13 mod m
IntDeinit(&base);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4317:
IntDeinit(&base);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4318:
IntDeinit(&base);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4337:
ok = ok && IntToU64(&r) == 96889010407ull % 1000000007ull;
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&m);- In
Int.Math.c:4338:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4339:
IntDeinit(&base);
IntDeinit(&exp);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4340:
IntDeinit(&exp);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4357:
ok = ok && (IntToU64(&r) * 17u) % 3120u == 1u;
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4358:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4359:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4379:
ok = ok && IntToU64(&r) == 5u;
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4380:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4381:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4400:
bool ok = !IntModInv(&r, &v, &m); // returns false
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4401:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4402:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4421:
ok = ok && (rv * rv) % 7u == 2u;
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4422:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4423:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4444:
ok = ok && (rv * rv) % 17u == 2u;
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4445:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4446:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4466:
ok = ok && (rv * rv) % 41u == 10u;
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4467:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4468:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4485:
bool ok = IntModSqrt(&r, &v, &m) && IntIsZero(&r);
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4486:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4487:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4505:
bool ok = IntModSqrt(&r, &v, &m) && IntToU64(&r) == 1u;
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4506:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4507:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4525:
bool ok = !IntModSqrt(&r, &v, &m);
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4526:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4527:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4544:
bool ok = !IntModSqrt(&r, &v, &m);
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4545:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4546:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4563:
bool ok = !IntModSqrt(&r, &v, &m);
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4564:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4565:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4584:
bool ok = IntIsProbablePrime(&prime) && !IntIsProbablePrime(&composite);
IntDeinit(&prime);
IntDeinit(&composite);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4585:
IntDeinit(&prime);
IntDeinit(&composite);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4602:
bool ok = !IntIsProbablePrime(&n);
IntDeinit(&n);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4620:
ok = ok && IntToU64(&r) == 1000003u;
IntDeinit(&v);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4621:
IntDeinit(&v);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4641:
ok = ok && IntNextPrime(&r1, &v1) && IntToU64(&r1) == 3u;
IntDeinit(&v0);
IntDeinit(&r0);
IntDeinit(&v1);- In
Int.Math.c:4642:
IntDeinit(&v0);
IntDeinit(&r0);
IntDeinit(&v1);
IntDeinit(&r1);- In
Int.Math.c:4643:
IntDeinit(&v0);
IntDeinit(&r0);
IntDeinit(&v1);
IntDeinit(&r1);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4644:
IntDeinit(&r0);
IntDeinit(&v1);
IntDeinit(&r1);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4661:
ok = ok && IntToU64(&r) == 123456ull * 7891011ull;
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);- In
Int.Math.c:4662:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4663:
IntDeinit(&x);
IntDeinit(&y);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4679:
ok = ok && IntToU64(&r) == 125u;
IntDeinit(&dvd);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);- In
Int.Math.c:4680:
IntDeinit(&dvd);
IntDeinit(&r);
ok = ok && LEAK_CLEAN(dbg);
DebugAllocatorDeinit(&dbg);- In
Int.Math.c:4713:
}
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4714:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
}- In
Int.Math.c:4715:
IntDeinit(&v);
IntDeinit(&m);
IntDeinit(&r);
}
}- In
Int.Math.c:4735:
ok = ok && IntCompare(&inverse, 23u) == 0;
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&inverse);- In
Int.Math.c:4736:
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&inverse);- In
Int.Math.c:4737:
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&inverse);
ok = ok && DebugAllocatorLiveCount(&dbg) == 0;- In
Int.Math.c:4757:
ok = ok && IntCompare(&check, 9u) == 0;
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&root);- In
Int.Math.c:4758:
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:4759:
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:4760:
IntDeinit(&modulus);
IntDeinit(&root);
IntDeinit(&check);
ok = ok && DebugAllocatorLiveCount(&dbg) == 0;- In
Int.Math.c:4780:
ok = ok && IntCompare(&check, 2u) == 0;
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&root);- In
Int.Math.c:4781:
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:4782:
IntDeinit(&value);
IntDeinit(&modulus);
IntDeinit(&root);
IntDeinit(&check);- In
Int.Math.c:4783:
IntDeinit(&modulus);
IntDeinit(&root);
IntDeinit(&check);
ok = ok && DebugAllocatorLiveCount(&dbg) == 0;- In
Int.Math.c:4807:
ok = ok && IntModSub(&r, &a3, &b3, &m) && IntIsZero(&r);
IntDeinit(&a1);
IntDeinit(&b1);
IntDeinit(&a2);- In
Int.Math.c:4808:
IntDeinit(&a1);
IntDeinit(&b1);
IntDeinit(&a2);
IntDeinit(&b2);- In
Int.Math.c:4809:
IntDeinit(&a1);
IntDeinit(&b1);
IntDeinit(&a2);
IntDeinit(&b2);
IntDeinit(&a3);- In
Int.Math.c:4810:
IntDeinit(&b1);
IntDeinit(&a2);
IntDeinit(&b2);
IntDeinit(&a3);
IntDeinit(&b3);- In
Int.Math.c:4811:
IntDeinit(&a2);
IntDeinit(&b2);
IntDeinit(&a3);
IntDeinit(&b3);
IntDeinit(&m);- In
Int.Math.c:4812:
IntDeinit(&b2);
IntDeinit(&a3);
IntDeinit(&b3);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4813:
IntDeinit(&a3);
IntDeinit(&b3);
IntDeinit(&m);
IntDeinit(&r);- In
Int.Math.c:4814:
IntDeinit(&b3);
IntDeinit(&m);
IntDeinit(&r);
ok = ok && DebugAllocatorLiveCount(&dbg) == 0;- In
Int.Math.c:4831:
ok = ok && IntCompare(&next, 101u) == 0;
IntDeinit(&value);
IntDeinit(&next);- In
Int.Math.c:4832:
IntDeinit(&value);
IntDeinit(&next);
ok = ok && DebugAllocatorLiveCount(&dbg) == 0;- In
Int.Math.c:4848:
bool ok = (error == false) && (prime == false);
IntDeinit(&value);
ok = ok && DebugAllocatorLiveCount(&dbg) == 0;- In
Io.Read.c:949:
StrDeinit(&bin_text);
StrDeinit(&oct_text);
IntDeinit(&dec);
IntDeinit(&hex);
IntDeinit(&bin);- In
Io.Read.c:950:
StrDeinit(&oct_text);
IntDeinit(&dec);
IntDeinit(&hex);
IntDeinit(&bin);
IntDeinit(&oct);- In
Io.Read.c:951:
IntDeinit(&dec);
IntDeinit(&hex);
IntDeinit(&bin);
IntDeinit(&oct);
DefaultAllocatorDeinit(&alloc);- In
Io.Read.c:952:
IntDeinit(&hex);
IntDeinit(&bin);
IntDeinit(&oct);
DefaultAllocatorDeinit(&alloc);- In
Io.Read.c:2571:
bool ok = (ZstrCompare(StrBegin(&t), "12345") == 0);
StrDeinit(&t);
IntDeinit(&v);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
DebugAllocatorDeinit(&dbg);- In
Io.Read.c:2586:
bool ok = (ZstrCompare(StrBegin(&t), "99") == 0);
StrDeinit(&t);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Read.c:2602:
bool ok = (ZstrCompare(StrBegin(&t), "255") == 0);
StrDeinit(&t);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Read.c:2620:
bool ok = (out == NULL) && (ZstrCompare(StrBegin(&t), "777") == 0);
StrDeinit(&t);
IntDeinit(&v);
DefaultAllocatorDeinit(&alloc);
return ok;- In
Io.Read.c:2828:
bool ok = (input != start); // pointer advanced => read succeeded
IntDeinit(&value);
ok = ok && (DebugAllocatorLiveCount(&dbg) == 0);
ok = ok && (DebugAllocatorLiveBytes(&dbg) == 0);
Last updated on